wave-agent-sdk 1.0.10 → 1.1.0

package/dist/services/worktreeHooks.js

@@ -0,0 +1,133 @@
+/**
+ * Worktree hooks — replace semantics (aligned with Claude Code).
+ *
+ * When `WorktreeCreate` / `WorktreeRemove` hooks are configured, wave delegates
+ * worktree creation/removal to the hooks instead of running git itself:
+ * - `WorktreeCreate`: the first successful hook's stdout (trimmed) is the
+ *   worktree path. All failures / empty output block creation.
+ * - `WorktreeRemove`: only fires for hook-based worktrees; wave never runs
+ *   `git worktree remove` for them. Failures are logged, never blocking.
+ *
+ * Unlike HookManager (DI-bound, per-agent), this module operates on a merged
+ * `PartialHookConfiguration` so it can be used from standalone CLI paths
+ * (packages/code) that load settings via `loadMergedWaveConfig`.
+ * See docs/specs/multi-agent/worktree.md.
+ */
+import { executeCommand } from "./hook.js";
+import { logger } from "../utils/globalLogger.js";
+export function hasWorktreeCreateHook(configuration) {
+    return hasWorktreeHook(configuration, "WorktreeCreate");
+}
+export function hasWorktreeRemoveHook(configuration) {
+    return hasWorktreeHook(configuration, "WorktreeRemove");
+}
+function hasWorktreeHook(configuration, event) {
+    return (configuration?.[event]?.some((config) => config.hooks.length > 0) ?? false);
+}
+/**
+ * Execute WorktreeCreate hooks and return the worktree path from hook stdout.
+ *
+ * The first successful hook (exit code 0) with non-empty stdout provides the
+ * worktree path (trimmed). Throws if every hook fails or none emits output —
+ * creation is blocked.
+ *
+ * Callers should check hasWorktreeCreateHook() before calling.
+ */
+export async function executeWorktreeCreateHook(name, configuration, context) {
+    const hookConfigs = configuration?.["WorktreeCreate"] ?? [];
+    const results = await runWorktreeHooks("WorktreeCreate", hookConfigs, context, { name });
+    const successful = results.find((r) => r.success && (r.stdout ?? "").trim().length > 0);
+    if (!successful) {
+        const failedOutputs = results
+            .filter((r) => !r.success)
+            .map((r) => `${r.command}: ${r.stderr || r.stdout || "no output"}`);
+        throw new Error(`WorktreeCreate hook failed: ${failedOutputs.join("; ") || "no successful output"}`);
+    }
+    return { worktreePath: successful.stdout.trim() };
+}
+/**
+ * Execute WorktreeRemove hooks for a hook-based worktree.
+ * Returns true if hooks ran, false if none were configured.
+ * Failures are logged but never throw (non-blocking, aligned with Claude Code).
+ */
+export async function executeWorktreeRemoveHook(worktreePath, configuration, context) {
+    const hookConfigs = configuration?.["WorktreeRemove"] ?? [];
+    if (hookConfigs.length === 0) {
+        return false;
+    }
+    const results = await runWorktreeHooks("WorktreeRemove", hookConfigs, context, { worktreePath });
+    for (const result of results) {
+        if (!result.success) {
+            logger?.error(`WorktreeRemove hook failed [${result.command}]: ${result.stderr || "no output"}`);
+        }
+    }
+    return true;
+}
+/**
+ * Run every configured hook command for a worktree event, mirroring
+ * HookManager.executeHooks' per-command handling: `${WAVE_PLUGIN_ROOT}` /
+ * `${CLAUDE_PLUGIN_ROOT}` substitution, plugin env injection, per-command
+ * timeout, and fire-and-forget async hooks. Results are tagged with the
+ * command for error messages.
+ */
+async function runWorktreeHooks(event, eventConfigs, context, extra) {
+    const baseContext = {
+        event,
+        projectDir: context.projectDir,
+        timestamp: new Date(),
+        sessionId: context.sessionId,
+        transcriptPath: context.transcriptPath,
+        cwd: context.projectDir,
+        env: context.env,
+        ...extra,
+    };
+    const results = [];
+    for (const config of eventConfigs) {
+        for (const hookCommand of config.hooks) {
+            const options = hookCommand.timeout
+                ? { timeout: hookCommand.timeout * 1000 }
+                : undefined;
+            // Build execution context with WAVE_PLUGIN_ROOT if this is a plugin hook
+            let command = hookCommand.command;
+            const execContext = hookCommand.pluginRoot
+                ? {
+                    ...baseContext,
+                    env: {
+                        ...(baseContext.env ?? {}),
+                        WAVE_PLUGIN_ROOT: hookCommand.pluginRoot,
+                        CLAUDE_PLUGIN_ROOT: hookCommand.pluginRoot,
+                    },
+                }
+                : baseContext;
+            if (hookCommand.pluginRoot) {
+                command = command.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, hookCommand.pluginRoot);
+                command = command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, hookCommand.pluginRoot);
+            }
+            if (hookCommand.async) {
+                // Async hooks are fire-and-forget (never block, never contribute a
+                // path for WorktreeCreate).
+                executeCommand(command, execContext, options).catch((error) => {
+                    const message = error instanceof Error ? error.message : "Unknown execution error";
+                    logger?.error(`[worktreeHooks] Async ${event} hook failed: ${message}`);
+                });
+                continue;
+            }
+            try {
+                const result = await executeCommand(command, execContext, options);
+                results.push({ ...result, command });
+            }
+            catch (error) {
+                // Rare — executeCommand resolves rather than rejects on failure.
+                const message = error instanceof Error ? error.message : "Unknown execution error";
+                results.push({
+                    success: false,
+                    stderr: message,
+                    duration: 0,
+                    timedOut: false,
+                    command,
+                });
+            }
+        }
+    }
+    return results;
+}

package/dist/tools/agentTool.js

@@ -1,6 +1,26 @@
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import { AGENT_TOOL_NAME } from "../constants/tools.js";
 import { countToolBlocks, formatToolTokenSummary, } from "../utils/messageOperations.js";
+/**
+ * Find the last streaming text/reasoning block across the subagent's messages.
+ * The message manager finalizes streaming content blocks (stage → "end")
+ * before a tool call begins, so at most one block is "streaming" at a time:
+ * its presence means the subagent is currently generating content (thinking or
+ * answering), its absence means it is in a tool phase (streaming/running/idle).
+ */
+function findActiveStreamingBlock(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const blocks = messages[i].blocks;
+        for (let j = blocks.length - 1; j >= 0; j--) {
+            const block = blocks[j];
+            if ((block.type === "text" || block.type === "reasoning") &&
+                block.stage === "streaming") {
+                return block;
+            }
+        }
+    }
+    return undefined;
+}
 /**
  * Agent tool plugin for launching specialized agents to handle complex tasks
  */
@@ -132,7 +152,13 @@ When using the Agent tool, you must specify a subagent_type parameter to select
                     return;
                 const messages = instance.messageManager.getMessages();
                 const tokens = instance.messageManager.getLatestTotalTokens();
-                const usedTools = instance.usedTools;
+                // While the subagent is streaming content (reasoning or reply text),
+                // show the last ONE tool plus the streaming content tail; otherwise
+                // (tool streaming/running/idle) keep the last two tools.
+                const activeStreaming = findActiveStreamingBlock(messages);
+                const usedTools = activeStreaming
+                    ? instance.usedTools.slice(-1)
+                    : instance.usedTools;
                 const toolCount = countToolBlocks(messages);
                 const summary = formatToolTokenSummary(toolCount, tokens);
                 const getDisplayParam = (t) => {
@@ -155,6 +181,15 @@ When using the Agent tool, you must specify a subagent_type parameter to select
                                 .map((t) => `${t.name} ${getDisplayParam(t)}`)
                                 .join("\n");
                 }
+                // Streaming content tail, on its own line below the tool lines
+                // (compact style, mirroring the tool's truncated compact params).
+                if (activeStreaming) {
+                    const flat = activeStreaming.content.replace(/\s+/g, " ").trim();
+                    if (flat) {
+                        const tail = flat.length > 30 ? `…${flat.slice(-30)}` : flat;
+                        shortResult += (shortResult ? "\n" : "") + tail;
+                    }
+                }
                 context.onShortResultUpdate?.(shortResult);
             });
             return new Promise((resolve) => {

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/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/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/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,