wave-agent-sdk 1.0.9 → 1.1.0

package/dist/tools/bashTool.js

@@ -11,6 +11,14 @@ 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";
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
+// After the shell exits, its last stdout/stderr chunks may still be in flight:
+// Node emits the child's 'exit' event as soon as the process terminates, then
+// delivers the remaining pipe data on a later event-loop turn and finally
+// emits 'close'. Finalization therefore waits for the streams to 'end' before
+// reading the buffers. This bound covers grandchildren that inherit the pipe
+// write ends (e.g. `sleep 30 &`), which would delay 'end' indefinitely — in
+// that case the shell's own output is returned, matching pre-existing behavior.
+const SHELL_STREAM_FLUSH_TIMEOUT_MS = 100;
 /**
  * Wrap a user command so we can append CWD tracking (`&& pwd -P`) without the
  * appended part being affected by trailing here-docs, unbalanced quotes, or
@@ -433,70 +441,125 @@ The working directory persists between commands. Try to maintain your current wo
                     updateRealtimeResults();
                 }
             });
-            child.on("exit", async (code) => {
-                isFinished = true;
-                if (context.foregroundTaskManager) {
-                    context.foregroundTaskManager.unregisterForegroundTask(foregroundTaskId);
+            // The 'exit' event fires before the stdio pipes have fully drained:
+            // Node emits 'exit' as soon as the process terminates, then delivers the
+            // remaining pipe data on a later event-loop turn and finally emits
+            // 'close'. Reading the buffers at 'exit' could therefore drop the
+            // shell's trailing output, written just before it exited (observed as
+            // empty stdout with exit code 0 for a fast `echo` under load). The
+            // result is only finalized after the streams have emitted 'end'. A
+            // bounded valve covers grandchildren that inherit the pipe write ends
+            // (e.g. `sleep 30 &`), which would delay 'end' indefinitely — in that
+            // case the shell's own output is returned, matching pre-existing
+            // behavior.
+            const finalizeShellResult = (code) => {
+                // Streams that may still hold undelivered data: real pipe streams not
+                // yet at EOF. Mocked child_process tests provide plain objects without
+                // `once` that never emit 'end' — skip the flush wait for them so the
+                // exit path is unchanged.
+                const pendingStreams = [child.stdout, child.stderr].filter((stream) => !!stream &&
+                    !stream.readableEnded &&
+                    typeof stream.once === "function");
+                let finalized = false;
+                const finish = () => {
+                    if (finalized)
+                        return;
+                    finalized = true;
+                    clearTimeout(flushTimer);
+                    completeShellResult(code);
+                };
+                if (pendingStreams.length === 0) {
+                    completeShellResult(code);
+                    return;
                 }
-                if (!isAborted && !isBackgrounded) {
-                    if (timeoutHandle) {
-                        clearTimeout(timeoutHandle);
+                const remainingStreams = new Set(pendingStreams);
+                const onStreamDone = (stream) => {
+                    remainingStreams.delete(stream);
+                    if (remainingStreams.size === 0) {
+                        finish();
                     }
-                    // Read the new CWD from the temporary file
-                    let newCwd;
-                    try {
-                        if (fs.existsSync(tempCwdFile)) {
-                            newCwd = fs.readFileSync(tempCwdFile, "utf8").trim();
-                            // Validate the path exists before calling the callback
-                            fs.accessSync(newCwd, fs.constants.F_OK);
-                        }
+                };
+                for (const stream of pendingStreams) {
+                    stream.once("end", () => onStreamDone(stream));
+                    stream.once("error", () => onStreamDone(stream));
+                }
+                // Safety valve for the grandchild case. Runs via setImmediate (which
+                // executes after the next poll), so any data still in the kernel pipe
+                // is delivered before the buffers are read.
+                const flushTimer = setTimeout(() => {
+                    if (!finalized) {
+                        setImmediate(finish);
                     }
-                    catch (fileError) {
-                        logger.warn(`Could not read or validate new CWD from temp file ${tempCwdFile}:`, fileError);
-                        newCwd = undefined;
+                }, SHELL_STREAM_FLUSH_TIMEOUT_MS);
+            };
+            const completeShellResult = (code) => {
+                // Read the new CWD from the temporary file
+                let newCwd;
+                try {
+                    if (fs.existsSync(tempCwdFile)) {
+                        newCwd = fs.readFileSync(tempCwdFile, "utf8").trim();
+                        // Validate the path exists before calling the callback
+                        fs.accessSync(newCwd, fs.constants.F_OK);
                     }
-                    finally {
-                        cleanupTempFile();
+                }
+                catch (fileError) {
+                    logger.warn(`Could not read or validate new CWD from temp file ${tempCwdFile}:`, fileError);
+                    newCwd = undefined;
+                }
+                finally {
+                    cleanupTempFile();
+                }
+                // If CWD changed, call the onCwdChange callback and add notification
+                let cwdMessage;
+                if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
+                    const isInSafeZone = context.permissionManager?.isPathInSafeZone?.(newCwd) ?? true;
+                    if (!isInSafeZone && context.originalWorkdir) {
+                        context.onCwdChange(context.originalWorkdir);
+                        cwdMessage = `Shell cwd was reset to ${context.originalWorkdir}`;
                     }
-                    // If CWD changed, call the onCwdChange callback and add notification
-                    let cwdMessage;
-                    if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
-                        const isInSafeZone = context.permissionManager?.isPathInSafeZone?.(newCwd) ?? true;
-                        if (!isInSafeZone && context.originalWorkdir) {
-                            context.onCwdChange(context.originalWorkdir);
-                            cwdMessage = `Shell cwd was reset to ${context.originalWorkdir}`;
-                        }
-                        else {
-                            context.onCwdChange(newCwd);
-                            cwdMessage = `Shell working directory changed to ${newCwd}`;
-                        }
+                    else {
+                        context.onCwdChange(newCwd);
+                        cwdMessage = `Shell working directory changed to ${newCwd}`;
                     }
-                    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 +
-                        (cwdMessage ? cwdMessage + "\n" : "") +
-                        (combinedOutput || `Command executed with exit code: ${exitCode}`);
-                    const content = processToolResult(finalOutput, BASH_MAX_OUTPUT_CHARS, "bash");
-                    const lines = combinedOutput.trim().split("\n");
-                    const shortResult = lines.length <= 3
-                        ? lines.join("\n")
-                        : `... +${lines.length - 3} lines\n` + lines.slice(-3).join("\n");
-                    resolve({
-                        success: exitCode === 0,
-                        content,
-                        shortResult: shortResult || undefined,
-                        error: exitCode !== 0
-                            ? `Command failed with exit code: ${exitCode}`
-                            : undefined,
-                    });
                 }
+                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 +
+                    (cwdMessage ? cwdMessage + "\n" : "") +
+                    (combinedOutput || `Command executed with exit code: ${exitCode}`);
+                const content = processToolResult(finalOutput, BASH_MAX_OUTPUT_CHARS, "bash");
+                const lines = combinedOutput.trim().split("\n");
+                const shortResult = lines.length <= 3
+                    ? lines.join("\n")
+                    : `... +${lines.length - 3} lines\n` + lines.slice(-3).join("\n");
+                resolve({
+                    success: exitCode === 0,
+                    content,
+                    shortResult: shortResult || undefined,
+                    error: exitCode !== 0
+                        ? `Command failed with exit code: ${exitCode}`
+                        : undefined,
+                });
+            };
+            child.on("exit", (code) => {
+                isFinished = true;
+                if (context.foregroundTaskManager) {
+                    context.foregroundTaskManager.unregisterForegroundTask(foregroundTaskId);
+                }
+                if (isAborted || isBackgrounded) {
+                    return;
+                }
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                finalizeShellResult(code);
             });
             child.on("error", (error) => {
                 isFinished = true;

package/dist/tools/editTool.js

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

package/dist/tools/enterWorktreeTool.d.ts

@@ -3,5 +3,5 @@
  * Mirrors Claude Code's EnterWorktree tool behavior and prompt.
  */
 import type { ToolPlugin } from "./types.js";
-export declare const ENTER_WORKTREE_TOOL_PROMPT = "Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.\n\n## When to Use\n\n- The user explicitly says \"worktree\" (e.g., \"start a worktree\", \"work in a worktree\", \"create a worktree\", \"use a worktree\")\n\n## When NOT to Use\n\n- The user asks to create a branch, switch branches, or work on a different branch \u2014 use git commands instead\n- The user asks to fix a bug or work on a feature \u2014 use normal git workflow unless they specifically mention worktrees\n- Never use this tool unless the user explicitly mentions \"worktree\"\n\n## Requirements\n\n- Must be in a git repository\n- Must not already be in a worktree\n\n## Behavior\n\n- Creates a new git worktree inside `.wave/worktrees/` with a new branch based on HEAD\n- Switches the session's working directory to the new worktree\n- Use ExitWorktree to leave the worktree mid-session (keep or remove). On session exit, if still in the worktree, the user will be prompted to keep or remove it\n\n## Parameters\n\n- `name` (optional): A name for the worktree. Each \"/\"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided.\n";
+export declare const ENTER_WORKTREE_TOOL_PROMPT = "Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.\n\n## When to Use\n\n- The user explicitly says \"worktree\" (e.g., \"start a worktree\", \"work in a worktree\", \"create a worktree\", \"use a worktree\")\n\n## When NOT to Use\n\n- The user asks to create a branch, switch branches, or work on a different branch \u2014 use git commands instead\n- The user asks to fix a bug or work on a feature \u2014 use normal git workflow unless they specifically mention worktrees\n- Never use this tool unless the user explicitly mentions \"worktree\"\n\n## Requirements\n\n- Must be in a git repository (or have a WorktreeCreate hook configured, in which case the hook creates the worktree)\n\n## Behavior\n\n- Creates a new git worktree inside `.wave/worktrees/` with a new branch based on HEAD\n- When a WorktreeCreate hook is configured, the hook creates the worktree instead (its stdout provides the worktree path) and no git command runs\n- Switches the session's working directory to the new worktree\n- Use ExitWorktree to leave the worktree mid-session (keep or remove). On session exit, if still in the worktree, the user will be prompted to keep or remove it\n\n## Parameters\n\n- `name` (optional): A name for the worktree. Each \"/\"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided.\n";
 export declare const enterWorktreeTool: ToolPlugin;

package/dist/tools/enterWorktreeTool.js

@@ -6,6 +6,7 @@ import { createWorktree, validateWorktreeName, generateWorktreeName, performPost
 import { getGitMainRepoRoot } from "../utils/gitUtils.js";
 import { ENTER_WORKTREE_TOOL_NAME } from "../constants/tools.js";
 import { logger } from "../utils/globalLogger.js";
+import { executeWorktreeCreateHook, hasWorktreeCreateHook, } from "../services/worktreeHooks.js";
 export const ENTER_WORKTREE_TOOL_PROMPT = `Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.
 
 ## When to Use
@@ -20,12 +21,12 @@ export const ENTER_WORKTREE_TOOL_PROMPT = `Use this tool ONLY when the user expl
 
 ## Requirements
 
-- Must be in a git repository
-- Must not already be in a worktree
+- Must be in a git repository (or have a WorktreeCreate hook configured, in which case the hook creates the worktree)
 
 ## Behavior
 
 - Creates a new git worktree inside \`.wave/worktrees/\` with a new branch based on HEAD
+- When a WorktreeCreate hook is configured, the hook creates the worktree instead (its stdout provides the worktree path) and no git command runs
 - Switches the session's working directory to the new worktree
 - Use ExitWorktree to leave the worktree mid-session (keep or remove). On session exit, if still in the worktree, the user will be prompted to keep or remove it
 
@@ -73,7 +74,46 @@ export const enterWorktreeTool = {
                 error: `Invalid worktree name: ${e.message}`,
             };
         }
-        // Resolve to main repo root so worktree creation works from within a subdirectory
+        // Hook-based creation first (allows user-configured VCS, including non-git)
+        const hookConfiguration = context.hookManager?.getConfiguration();
+        if (hasWorktreeCreateHook(hookConfiguration)) {
+            try {
+                const { worktreePath } = await executeWorktreeCreateHook(name, hookConfiguration, {
+                    projectDir: context.workdir,
+                    sessionId: context.sessionId ?? "",
+                    transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
+                    env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
+                });
+                // Hook-based worktrees skip post-creation setup; the hook script owns
+                // initialization. repoRoot falls back to the workdir for non-git repos.
+                const hookBasedSession = {
+                    originalCwd: context.workdir,
+                    worktreePath,
+                    worktreeBranch: "",
+                    worktreeName: name,
+                    isNew: true,
+                    repoRoot: getGitMainRepoRoot(context.workdir) ?? context.workdir,
+                    hookBased: true,
+                };
+                const aiManager = context.aiManager;
+                if (aiManager) {
+                    aiManager.setWorktreeSession(hookBasedSession);
+                    aiManager.setWorkdir(worktreePath);
+                }
+                return {
+                    success: true,
+                    content: `Created worktree at ${worktreePath}. The session is now working in the worktree. Use ExitWorktree to leave mid-session, or exit the session to be prompted. WorktreeCreate hooks were executed.`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    content: `Failed to create worktree: ${error.message}`,
+                    error: "WorktreeCreate hook failed",
+                };
+            }
+        }
+        // Git-based fallback
         const mainRepoRoot = getGitMainRepoRoot(context.workdir);
         if (!mainRepoRoot) {
             return {
@@ -112,39 +152,12 @@ export const enterWorktreeTool = {
             aiManager.setWorktreeSession(session);
             aiManager.setWorkdir(worktreeInfo.path);
         }
-        // Trigger WorktreeCreate hook if worktree is new
-        let hookTriggered = false;
-        if (session.isNew && context.hookManager) {
-            try {
-                const hookResults = await context.hookManager.executeHooks("WorktreeCreate", {
-                    event: "WorktreeCreate",
-                    projectDir: worktreeInfo.path,
-                    timestamp: new Date(),
-                    sessionId: context.sessionId ?? "",
-                    transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
-                    cwd: worktreeInfo.path,
-                    worktreeName: worktreeInfo.name,
-                    env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
-                });
-                if (context.messageManager) {
-                    context.hookManager.processHookResults("WorktreeCreate", hookResults, context.messageManager);
-                }
-                hookTriggered = true;
-            }
-            catch (error) {
-                // Non-blocking: log but don't fail the tool
-                logger?.warn("WorktreeCreate hooks execution failed:", error);
-            }
-        }
         const branchInfo = worktreeInfo.branch
             ? ` on branch ${worktreeInfo.branch}`
             : "";
-        const hookInfo = hookTriggered
-            ? " WorktreeCreate hooks were executed."
-            : "";
         return {
             success: true,
-            content: `Created worktree at ${worktreeInfo.path}${branchInfo}. The session is now working in the worktree. Use ExitWorktree to leave mid-session, or exit the session to be prompted.${hookInfo}`,
+            content: `Created worktree at ${worktreeInfo.path}${branchInfo}. The session is now working in the worktree. Use ExitWorktree to leave mid-session, or exit the session to be prompted.`,
         };
     },
 };

package/dist/tools/exitWorktreeTool.js

@@ -5,6 +5,7 @@
 import { removeWorktree, countWorktreeChanges, } from "../utils/worktreeUtils.js";
 import { EXIT_WORKTREE_TOOL_NAME } from "../constants/tools.js";
 import { logger } from "../utils/globalLogger.js";
+import { executeWorktreeRemoveHook } from "../services/worktreeHooks.js";
 export const EXIT_WORKTREE_TOOL_PROMPT = `Exit a worktree session created by EnterWorktree and return the session to the original working directory.
 
 ## Scope
@@ -128,32 +129,29 @@ export const exitWorktreeTool = {
         };
         // Count changes BEFORE removing the worktree (directory will be gone after)
         const summary = countWorktreeChanges(worktreePath, session.originalHeadCommit) ?? { changedFiles: 0, commits: 0 };
-        // 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 {
-                const hookResults = await context.hookManager.executeHooks("WorktreeRemove", {
-                    event: "WorktreeRemove",
-                    projectDir: originalCwd,
-                    timestamp: new Date(),
-                    sessionId: context.sessionId ?? "",
-                    transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
-                    cwd: originalCwd,
-                    worktreePath,
-                    env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
-                });
-                if (context.messageManager) {
-                    context.hookManager.processHookResults("WorktreeRemove", hookResults, context.messageManager);
-                }
-                hookTriggered = true;
+        let hookNote = "";
+        if (session.hookBased) {
+            // Hook-based worktree: delegate removal to the WorktreeRemove hook.
+            // wave never runs `git worktree remove` for hook-based worktrees.
+            const configuration = context.hookManager?.getConfiguration();
+            const hookRan = await executeWorktreeRemoveHook(worktreePath, configuration, {
+                projectDir: originalCwd,
+                sessionId: context.sessionId ?? "",
+                transcriptPath: context.messageManager?.getTranscriptPath?.() ?? "",
+                env: Object.fromEntries(Object.entries(context.sessionEnv ?? process.env).filter((e) => e[1] !== undefined)),
+            });
+            if (hookRan) {
+                hookNote = " WorktreeRemove hooks were executed.";
             }
-            catch (error) {
-                // Non-blocking: log but don't fail the tool
-                logger?.warn("WorktreeRemove hooks execution failed:", error);
+            else {
+                logger?.warn(`No WorktreeRemove hook configured, hook-based worktree left at: ${worktreePath}`);
+                hookNote =
+                    " No WorktreeRemove hook configured, hook-based worktree left at the path above.";
             }
         }
-        removeWorktree(worktreeInfo);
+        else {
+            removeWorktree(worktreeInfo);
+        }
         // Clear session state and restore CWD
         const aiManager = context.aiManager;
         if (aiManager) {
@@ -170,9 +168,6 @@ export const exitWorktreeTool = {
         const discardNote = discardParts.length > 0
             ? ` Discarded ${discardParts.join(" and ")}.`
             : "";
-        const hookNote = hookTriggered
-            ? " WorktreeRemove hooks were executed."
-            : "";
         return {
             success: true,
             content: `Exited and removed worktree at ${worktreePath}.${discardNote} Session is now back in ${originalCwd}.${hookNote}`,

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/agent.d.ts

@@ -106,4 +106,9 @@ export interface AgentCallbacks extends MessageManagerCallbacks, BackgroundTaskM
     onCommandRunningChange?: (running: boolean) => void;
     onWorkdirChange?: (newCwd: string) => void;
     onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
+    /** Streaming content from the compaction fork (accumulated). Reasoning
+     * chunks fall back to this channel when no reasoning callback is provided. */
+    onCompactionContentUpdate?: (content: string) => void;
+    /** Streaming reasoning from the compaction fork (accumulated). */
+    onCompactionReasoningUpdate?: (content: string) => void;
 }

package/dist/types/hooks.d.ts

@@ -22,7 +22,7 @@ export interface HookExecutionContext {
     toolName?: string;
     projectDir: string;
     timestamp: Date;
-    worktreeName?: string;
+    name?: string;
     worktreePath?: string;
     planFilePath?: string;
 }
@@ -33,6 +33,8 @@ export interface HookExecutionResult {
     stderr?: string;
     duration: number;
     timedOut: boolean;
+    /** The executed command, tagged onto results by callers that iterate multiple hooks */
+    command?: string;
 }
 export interface HookExecutionOptions {
     timeout?: number;
@@ -107,7 +109,6 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
     env?: Record<string, string>;
     userPrompt?: string;
     subagentType?: string;
-    worktreeName?: string;
     oldCwd?: string;
     newCwd?: string;
     source?: SessionStartSource;

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/types/skills.d.ts

@@ -85,7 +85,6 @@ export declare const SKILL_DEFAULTS: {
     readonly PROJECT_SKILLS_DIR: ".wave/skills";
     readonly SKILL_FILE_NAME: "SKILL.md";
     readonly MAX_NAME_LENGTH: 64;
-    readonly MAX_DESCRIPTION_LENGTH: 1024;
     readonly MIN_DESCRIPTION_LENGTH: 1;
     readonly NAME_PATTERN: RegExp;
     readonly MAX_METADATA_CACHE: 1000;

package/dist/types/skills.js

@@ -7,7 +7,6 @@ export const SKILL_DEFAULTS = {
     PROJECT_SKILLS_DIR: ".wave/skills",
     SKILL_FILE_NAME: "SKILL.md",
     MAX_NAME_LENGTH: 64,
-    MAX_DESCRIPTION_LENGTH: 1024,
     MIN_DESCRIPTION_LENGTH: 1,
     NAME_PATTERN: /^[a-z0-9-]+$/,
     MAX_METADATA_CACHE: 1000,

package/dist/utils/asyncWorkRegistry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Registry of live async work that must drain before the agent is destroyed.
+ *
+ * Fire-and-forget work (dispatch, background subagents, fork subagents)
+ * registers its promise here so destroy() can wait deterministically instead
+ * of silently abandoning it (the "ghost work" class of #1808). The registry
+ * swallows rejections so an unregistered fire-and-forget caller can't turn a
+ * settled-then-removed promise into an unhandled rejection.
+ */
+export declare class AsyncWorkRegistry {
+    private readonly drainTimeoutMs;
+    private work;
+    private waiters;
+    constructor(drainTimeoutMs?: number);
+    get size(): number;
+    isEmpty(): boolean;
+    /**
+     * Register a promise as live work. The promise is removed when it settles
+     * (fulfilled or rejected); rejections are consumed here so tracking never
+     * produces an unhandled rejection. Returns the original promise unchanged
+     * so the caller can still await it.
+     */
+    track<T>(promise: Promise<T>): Promise<T>;
+    private remove;
+    /**
+     * Wait until the registry is empty, or until the timeout elapses. Loops
+     * until empty: work registered after an await point is still drained.
+     * Returns true if drained, false on timeout (leftover work is no longer
+     * lifecycle-managed).
+     */
+    drain(timeoutMs?: number): Promise<boolean>;
+}

package/dist/utils/asyncWorkRegistry.js

@@ -0,0 +1,81 @@
+/**
+ * Registry of live async work that must drain before the agent is destroyed.
+ *
+ * Fire-and-forget work (dispatch, background subagents, fork subagents)
+ * registers its promise here so destroy() can wait deterministically instead
+ * of silently abandoning it (the "ghost work" class of #1808). The registry
+ * swallows rejections so an unregistered fire-and-forget caller can't turn a
+ * settled-then-removed promise into an unhandled rejection.
+ */
+export class AsyncWorkRegistry {
+    constructor(drainTimeoutMs = 10000) {
+        this.drainTimeoutMs = drainTimeoutMs;
+        this.work = new Set();
+        this.waiters = [];
+    }
+    get size() {
+        return this.work.size;
+    }
+    isEmpty() {
+        return this.work.size === 0;
+    }
+    /**
+     * Register a promise as live work. The promise is removed when it settles
+     * (fulfilled or rejected); rejections are consumed here so tracking never
+     * produces an unhandled rejection. Returns the original promise unchanged
+     * so the caller can still await it.
+     */
+    track(promise) {
+        this.work.add(promise);
+        promise.then(() => this.remove(promise), () => this.remove(promise));
+        return promise;
+    }
+    remove(promise) {
+        this.work.delete(promise);
+        if (this.work.size === 0) {
+            const waiters = this.waiters;
+            this.waiters = [];
+            for (const resolve of waiters) {
+                resolve();
+            }
+        }
+    }
+    /**
+     * Wait until the registry is empty, or until the timeout elapses. Loops
+     * until empty: work registered after an await point is still drained.
+     * Returns true if drained, false on timeout (leftover work is no longer
+     * lifecycle-managed).
+     */
+    async drain(timeoutMs = this.drainTimeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (this.work.size > 0) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                return false;
+            }
+            // Wait for the registry to empty, or for the timeout — whichever comes
+            // first (a tracked promise may never settle).
+            let waiter;
+            const notified = new Promise((resolve) => {
+                waiter = resolve;
+                this.waiters.push(resolve);
+            });
+            let timer;
+            const timedOut = new Promise((resolve) => {
+                timer = setTimeout(resolve, remaining);
+            });
+            await Promise.race([notified, timedOut]);
+            if (timer)
+                clearTimeout(timer);
+            // If the timer won, the work set is still non-empty: drop our waiter so
+            // a later drain isn't woken by a stale notification. If notified won,
+            // remove() already cleared the waiters array.
+            if (waiter && this.work.size > 0) {
+                const idx = this.waiters.indexOf(waiter);
+                if (idx >= 0)
+                    this.waiters.splice(idx, 1);
+            }
+        }
+        return true;
+    }
+}

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;