wave-agent-sdk 0.15.0 → 0.15.2

package/src/services/jsonlHandler.ts

@@ -8,7 +8,7 @@ import { dirname } from "path";
 import { getLastLine } from "../utils/fileUtils.js";
 
 import type { Message } from "../types/index.js";
-import type { SessionMessage, SessionFilename } from "../types/session.js";
+import type { SessionFilename } from "../types/session.js";
 
 /**
  * JSONL write options
@@ -56,13 +56,7 @@ export class JsonlHandler {
       return;
     }
 
-    // Convert to SessionMessage format with timestamps
-    const sessionMessages: SessionMessage[] = messages.map((message) => ({
-      ...message,
-      timestamp: new Date().toISOString(),
-    }));
-
-    return this.append(filePath, sessionMessages);
+    return this.append(filePath, messages);
   }
 
   /**
@@ -70,7 +64,7 @@ export class JsonlHandler {
    */
   async append(
     filePath: string,
-    messages: SessionMessage[],
+    messages: Message[],
     options?: JsonlWriteOptions,
   ): Promise<void> {
     if (messages.length === 0) {
@@ -85,16 +79,10 @@ export class JsonlHandler {
     // Ensure directory exists
     await this.ensureDirectory(dirname(filePath));
 
-    // Convert messages to JSONL lines (always compact JSON)
+    // Convert messages to JSONL lines (compact JSON, timestamp first)
     const lines = messages.map((message) => {
-      const { timestamp: existingTimestamp, ...messageWithoutTimestamp } =
-        message;
-      const messageWithTimestamp = {
-        timestamp: existingTimestamp || new Date().toISOString(),
-        ...messageWithoutTimestamp,
-      };
-
-      return JSON.stringify(messageWithTimestamp);
+      const { timestamp, ...rest } = message;
+      return JSON.stringify({ timestamp, ...rest });
     });
 
     const content = lines.join("\n") + "\n";
@@ -116,7 +104,7 @@ export class JsonlHandler {
   /**
    * Read all messages from JSONL file (simplified - no metadata handling)
    */
-  async read(filePath: string): Promise<SessionMessage[]> {
+  async read(filePath: string): Promise<Message[]> {
     try {
       const content = await readFile(filePath, "utf8");
       const lines = content
@@ -128,14 +116,14 @@ export class JsonlHandler {
         return [];
       }
 
-      const allMessages: SessionMessage[] = [];
+      const allMessages: Message[] = [];
 
       // Parse all messages (no metadata line to skip)
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
 
         try {
-          const message = JSON.parse(line) as SessionMessage;
+          const message = JSON.parse(line) as Message;
           if (message.timestamp) allMessages.push(message);
         } catch (error) {
           // Throw error for invalid JSON lines with line number
@@ -155,7 +143,7 @@ export class JsonlHandler {
   /**
    * Get the last message from JSONL file using efficient file reading (simplified)
    */
-  async getLastMessage(filePath: string): Promise<SessionMessage | null> {
+  async getLastMessage(filePath: string): Promise<Message | null> {
     try {
       // First check if file exists
       try {
@@ -176,7 +164,7 @@ export class JsonlHandler {
 
       try {
         const parsed = JSON.parse(lastLine);
-        return parsed as SessionMessage;
+        return parsed as Message;
       } catch (error) {
         throw new Error(`Invalid JSON in last line of "${filePath}": ${error}`);
       }
@@ -190,7 +178,7 @@ export class JsonlHandler {
   /**
    * Validate messages before writing
    */
-  private validateMessages(messages: SessionMessage[]): void {
+  private validateMessages(messages: Message[]): void {
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i];
 

package/src/services/memory.ts

@@ -8,8 +8,26 @@ import { getGitCommonDir } from "../utils/gitUtils.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
 
 export class MemoryService {
+  private _cachedProjectMemory: string = "";
+  private _cachedUserMemory: string = "";
+  private _cachedCombinedMemory: string | null = null;
+
   constructor(private container: Container) {}
 
+  public get cachedProjectMemory(): string {
+    return this._cachedProjectMemory;
+  }
+
+  public get cachedUserMemory(): string {
+    return this._cachedUserMemory;
+  }
+
+  public clearCache(): void {
+    this._cachedProjectMemory = "";
+    this._cachedUserMemory = "";
+    this._cachedCombinedMemory = null;
+  }
+
   /**
    * Get the project-specific auto-memory directory.
    * Uses the git common directory to ensure worktrees share the same memory.
@@ -143,24 +161,19 @@ export class MemoryService {
   }
 
   async getCombinedMemoryContent(workdir: string): Promise<string> {
-    // Read memory file content
-    const memoryContent = await this.readMemoryFile(workdir);
-
-    // Read user-level memory content
-    const userMemoryContent = await this.getUserMemoryContent();
-
-    // Merge project memory and user memory
-    let combinedMemory = "";
-    if (memoryContent.trim()) {
-      combinedMemory += memoryContent;
+    if (this._cachedCombinedMemory !== null) {
+      return this._cachedCombinedMemory;
     }
-    if (userMemoryContent.trim()) {
-      if (combinedMemory) {
-        combinedMemory += "\n\n";
-      }
-      combinedMemory += userMemoryContent;
+    this._cachedProjectMemory = await this.readMemoryFile(workdir);
+    this._cachedUserMemory = await this.getUserMemoryContent();
+
+    let combined = "";
+    if (this._cachedProjectMemory.trim()) combined += this._cachedProjectMemory;
+    if (this._cachedUserMemory.trim()) {
+      if (combined) combined += "\n\n";
+      combined += this._cachedUserMemory;
     }
-
-    return combinedMemory;
+    this._cachedCombinedMemory = combined;
+    return combined;
   }
 }

package/src/services/session.ts

@@ -20,7 +20,6 @@ import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
 import type { Message } from "../types/index.js";
-import type { SessionMessage } from "../types/session.js";
 import { PathEncoder } from "../utils/pathEncoder.js";
 import { JsonlHandler } from "../services/jsonlHandler.js";
 import { extractLatestTotalTokens } from "../utils/tokenCalculation.js";
@@ -228,19 +227,14 @@ export async function appendMessages(
     );
   }
 
-  const messagesWithTimestamp: SessionMessage[] = newMessages.map((msg) => ({
-    timestamp: new Date().toISOString(),
-    ...msg,
-  }));
-
-  await jsonlHandler.append(filePath, messagesWithTimestamp, {
+  await jsonlHandler.append(filePath, newMessages, {
     atomic: false,
   });
 
   // Update index
   const encoder = new PathEncoder();
   const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-  const lastMessage = messagesWithTimestamp[messagesWithTimestamp.length - 1];
+  const lastMessage = newMessages[newMessages.length - 1];
 
   // Get first message content if it's a new session or we don't have it
   let firstMessage: string | undefined;
@@ -333,12 +327,7 @@ export async function loadSessionFromJsonl(
       id: sessionId,
       rootSessionId: rootSessionId || sessionId,
       parentSessionId,
-      messages: messages.map((msg) => {
-        // Remove timestamp property for backward compatibility
-        const { timestamp: _ignored, ...messageWithoutTimestamp } = msg;
-        void _ignored; // Use the variable to avoid eslint error
-        return messageWithoutTimestamp;
-      }),
+      messages,
       metadata: {
         workdir,
         lastActiveAt: lastMessage

package/src/tools/agentTool.ts

@@ -159,20 +159,39 @@ When using the Agent tool, you must specify a subagent_type parameter to select
 
           const messages = instance.messageManager.getMessages();
           const tokens = instance.messageManager.getLatestTotalTokens();
-          const lastTools = instance.lastTools;
+          const usedTools = instance.usedTools;
 
           const toolCount = countToolBlocks(messages);
           const summary = formatToolTokenSummary(toolCount, tokens);
 
+          const getDisplayParam = (t: {
+            name: string;
+            parameters: string;
+            compactParams?: string;
+            stage?: string;
+          }) => {
+            if (
+              (t.stage === "end" || t.stage === "running") &&
+              t.compactParams
+            ) {
+              return t.compactParams;
+            }
+            const flat = t.parameters.replace(/\n/g, "\\n");
+            return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
+          };
+
           let shortResult = "";
           if (toolCount > 2) {
             shortResult += "... ";
           }
-          if (lastTools.length > 0) {
-            shortResult += `${lastTools.join(", ")} `;
-          }
-
           shortResult += summary;
+          if (usedTools.length > 0) {
+            shortResult +=
+              "\n" +
+              usedTools
+                .map((t) => `${t.name} ${getDisplayParam(t)}`)
+                .join("\n");
+          }
 
           context.onShortResultUpdate?.(shortResult);
         },

package/src/tools/bashTool.ts

@@ -80,7 +80,7 @@ export const bashTool: ToolPlugin = {
     },
   },
   prompt: () => `
-Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
+Executes a given bash command with optional timeout, ensuring proper handling and security measures. Each invocation runs in a fresh shell process starting from the project root.
 
 IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.
 
@@ -139,10 +139,7 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
 - Do not retry failing commands in a sleep loop — diagnose the root cause.
 - If waiting for a background task you started with \`run_in_background\`, you will be notified when it completes — do not poll.
 - If you must poll an external process, use a check command (e.g. \`gh run view\`) rather than sleeping first.
-- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.
-
-# CWD management
-Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it. When you use \`cd\`, the shell working directory will be reset to the original working directory after the command completes.`,
+- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,

package/src/tools/cronCreateTool.ts

@@ -1,30 +1,73 @@
 import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { CRON_CREATE_TOOL_NAME } from "../constants/tools.js";
+import { cronToHuman } from "../utils/cronToHuman.js";
+import { parseCronExpression } from "../utils/parseCronExpression.js";
+
+const DEFAULT_MAX_AGE_DAYS = 7;
+const MAX_JOBS = 50;
+
+const CRON_CREATE_DESCRIPTION = `Schedule a prompt to run at a future time within this Wave session — either recurring on a cron schedule, or once at a specific time.`;
+
+const CRON_CREATE_PROMPT = `Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.
+
+Uses standard 5-field cron in the user's local timezone: minute hour day-of-month month day-of-week. "0 9 * * *" means 9am local — no timezone conversion needed.
+
+## One-shot tasks (recurring: false)
+
+For "remind me at X" or "at <time>, do Y" requests — fire once then auto-delete.
+Pin minute/hour/day-of-month/month to specific values:
+  "remind me at 2:30pm today to check the deploy" → cron: "30 14 <today_dom> <today_month> *", recurring: false
+  "tomorrow morning, run the smoke test" → cron: "57 8 <tomorrow_dom> <tomorrow_month> *", recurring: false
+
+## Recurring jobs (recurring: true, the default)
+
+For "every N minutes" / "every hour" / "weekdays at 9am" requests:
+  "*/5 * * * *" (every 5 min), "0 * * * *" (hourly), "0 9 * * 1-5" (weekdays at 9am local)
+
+## Avoid the :00 and :30 minute marks when the task allows it
+
+Every user who asks for "9am" gets \`0 9\`, and every user who asks for "hourly" gets \`0 *\` — which means requests from across the planet land on the API at the same instant. When the user's request is approximate, pick a minute that is NOT 0 or 30:
+  "every morning around 9" → "57 8 * * *" or "3 9 * * *" (not "0 9 * * *")
+  "hourly" → "7 * * * *" (not "0 * * * *")
+  "in an hour or so, remind me to..." → pick whatever minute you land on, don't round
+
+Only use minute 0 or 30 when the user names that exact time and clearly means it ("at 9:00 sharp", "at half past", coordinating with a meeting). When in doubt, nudge a few minutes early or late — the user will not notice, and the fleet will.
+
+## Session-only
+
+Jobs live only in this Wave session — nothing is written to disk, and the job is gone when Wave exits.
+
+## Runtime behavior
+
+Jobs only fire while the REPL is idle (not mid-query). The scheduler adds a small deterministic jitter on top of whatever you pick: recurring tasks fire up to 10% of their period late (max 15 min); one-shot tasks landing on :00 or :30 fire up to 90s early. Picking an off-minute is still the bigger lever.
+
+Recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days — they fire one final time, then are deleted. This bounds session lifetime. Tell the user about the ${DEFAULT_MAX_AGE_DAYS}-day limit when scheduling recurring jobs.
+
+Returns a job ID you can pass to CronDelete.`;
 
 export const cronCreateTool: ToolPlugin = {
   name: CRON_CREATE_TOOL_NAME,
+  shouldDefer: true,
   config: {
     type: "function",
     function: {
       name: CRON_CREATE_TOOL_NAME,
-      description:
-        "Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.",
+      description: CRON_CREATE_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
           cron: {
             type: "string",
             description:
-              'Standard 5-field cron expression in local time: "M H DoM Mon DoW"',
+              'Standard 5-field cron expression in local time: "M H DoM Mon DoW" (e.g. "*/5 * * * *" = every 5 minutes, "30 14 28 2 *" = Feb 28 at 2:30pm local once).',
           },
           prompt: {
             type: "string",
-            description: "The prompt to enqueue at each fire time",
+            description: "The prompt to enqueue at each fire time.",
           },
           recurring: {
             type: "boolean",
-            description:
-              "Default: true. true = fire on every cron match until deleted or auto-expired after 7 days. false = fire once at the next match, then auto-delete",
+            description: `true (default) = fire on every cron match until deleted or auto-expired after ${DEFAULT_MAX_AGE_DAYS} days. false = fire once at the next match, then auto-delete. Use false for "remind me at X" one-shot requests with pinned minute/hour/dom/month.`,
             default: true,
           },
         },
@@ -32,6 +75,7 @@ export const cronCreateTool: ToolPlugin = {
       },
     },
   },
+  prompt: () => CRON_CREATE_PROMPT,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,
@@ -50,6 +94,25 @@ export const cronCreateTool: ToolPlugin = {
       };
     }
 
+    // Validate cron expression
+    if (!parseCronExpression(cron)) {
+      return {
+        success: false,
+        content: "",
+        error: `Invalid cron expression '${cron}'. Expected 5 fields: M H DoM Mon DoW.`,
+      };
+    }
+
+    // Check max jobs limit
+    const existingJobs = context.cronManager.listJobs();
+    if (existingJobs.length >= MAX_JOBS) {
+      return {
+        success: false,
+        content: "",
+        error: `Too many scheduled jobs (max ${MAX_JOBS}). Cancel one first.`,
+      };
+    }
+
     try {
       const job = context.cronManager.createJob({
         cron,
@@ -57,10 +120,20 @@ export const cronCreateTool: ToolPlugin = {
         recurring,
       });
 
+      const humanSchedule = cronToHuman(cron);
+      const where = "Session-only (not written to disk, dies when Wave exits)";
+      const resultMessage = recurring
+        ? `Scheduled recurring job ${job.id} (${humanSchedule}). ${where}. Auto-expires after ${DEFAULT_MAX_AGE_DAYS} days. Use CronDelete to cancel sooner.`
+        : `Scheduled one-shot task ${job.id} (${humanSchedule}). ${where}. It will fire once then auto-delete.`;
+
       return {
         success: true,
-        content: JSON.stringify({ id: job.id }, null, 2),
-        shortResult: `Scheduled job ${job.id}`,
+        content: JSON.stringify(
+          { id: job.id, humanSchedule, recurring },
+          null,
+          2,
+        ),
+        shortResult: resultMessage,
       };
     } catch (error) {
       return {

package/src/tools/cronDeleteTool.ts

@@ -1,14 +1,18 @@
 import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { CRON_DELETE_TOOL_NAME } from "../constants/tools.js";
 
+const CRON_DELETE_DESCRIPTION = "Cancel a scheduled cron job by ID";
+
+const CRON_DELETE_PROMPT = `Cancel a cron job previously scheduled with CronCreate. Removes it from the in-memory session store.`;
+
 export const cronDeleteTool: ToolPlugin = {
   name: CRON_DELETE_TOOL_NAME,
+  shouldDefer: true,
   config: {
     type: "function",
     function: {
       name: CRON_DELETE_TOOL_NAME,
-      description:
-        "Cancel a cron job previously scheduled with CronCreate. Removes it from the in-memory session store.",
+      description: CRON_DELETE_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
@@ -21,6 +25,7 @@ export const cronDeleteTool: ToolPlugin = {
       },
     },
   },
+  prompt: () => CRON_DELETE_PROMPT,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,

package/src/tools/cronListTool.ts

@@ -1,20 +1,25 @@
 import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { CRON_LIST_TOOL_NAME } from "../constants/tools.js";
 
+const CRON_LIST_DESCRIPTION = "List scheduled cron jobs";
+
+const CRON_LIST_PROMPT = `List all cron jobs scheduled via CronCreate in this session.`;
+
 export const cronListTool: ToolPlugin = {
   name: CRON_LIST_TOOL_NAME,
+  shouldDefer: true,
   config: {
     type: "function",
     function: {
       name: CRON_LIST_TOOL_NAME,
-      description:
-        "List all cron jobs scheduled via CronCreate in this session.",
+      description: CRON_LIST_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {},
       },
     },
   },
+  prompt: () => CRON_LIST_PROMPT,
   execute: async (
     _args: Record<string, unknown>,
     context: ToolContext,

package/src/tools/enterWorktreeTool.ts

@@ -0,0 +1,183 @@
+/**
+ * EnterWorktree tool - creates an isolated git worktree and switches the session into it.
+ * Mirrors Claude Code's EnterWorktree tool behavior and prompt.
+ */
+
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import {
+  getCurrentWorktreeSession,
+  setCurrentWorktreeSession,
+  type WorktreeSession,
+} from "../utils/worktreeSession.js";
+import {
+  createWorktree,
+  validateWorktreeName,
+  generateWorktreeName,
+} from "../utils/worktreeUtils.js";
+import { getGitMainRepoRoot } from "../utils/gitUtils.js";
+import { ENTER_WORKTREE_TOOL_NAME } from "../constants/tools.js";
+import { logger } from "../utils/globalLogger.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
+
+- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree", "use a worktree")
+
+## When NOT to Use
+
+- The user asks to create a branch, switch branches, or work on a different branch — use git commands instead
+- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
+- Never use this tool unless the user explicitly mentions "worktree"
+
+## Requirements
+
+- Must be in a git repository
+- Must not already be in a worktree
+
+## Behavior
+
+- Creates a new git worktree inside \`.wave/worktrees/\` with a new branch based on HEAD
+- 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
+
+## Parameters
+
+- \`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.
+`;
+
+export const enterWorktreeTool: ToolPlugin = {
+  name: ENTER_WORKTREE_TOOL_NAME,
+  shouldDefer: true,
+  config: {
+    type: "function",
+    function: {
+      name: ENTER_WORKTREE_TOOL_NAME,
+      description: ENTER_WORKTREE_TOOL_PROMPT,
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description:
+              'Optional 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.',
+          },
+        },
+      },
+    },
+  },
+  prompt: () => ENTER_WORKTREE_TOOL_PROMPT,
+
+  async execute(
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> {
+    // Validate not already in a worktree created by this session
+    if (getCurrentWorktreeSession()) {
+      return {
+        success: false,
+        content:
+          "Already in a worktree session. Use ExitWorktree to leave before creating a new one.",
+        error: "Already in a worktree session",
+      };
+    }
+
+    const name = (args.name as string) || generateWorktreeName();
+
+    // Validate the worktree name
+    try {
+      validateWorktreeName(name);
+    } catch (e) {
+      return {
+        success: false,
+        content: `Invalid worktree name: ${(e as Error).message}`,
+        error: `Invalid worktree name: ${(e as Error).message}`,
+      };
+    }
+
+    // Resolve to main repo root so worktree creation works from within a subdirectory
+    const mainRepoRoot = getGitMainRepoRoot(context.workdir);
+    if (!mainRepoRoot) {
+      return {
+        success: false,
+        content:
+          "Cannot create a worktree: not in a git repository. Configure WorktreeCreate and WorktreeRemove hooks in settings.json to use worktree isolation with other VCS systems.",
+        error: "Not in a git repository",
+      };
+    }
+
+    // Create the worktree (captures originalHeadCommit internally)
+    const worktreeInfo = createWorktree(name, mainRepoRoot);
+
+    // Build session state
+    const session: WorktreeSession = {
+      originalCwd: context.workdir,
+      worktreePath: worktreeInfo.path,
+      worktreeBranch: worktreeInfo.branch,
+      worktreeName: worktreeInfo.name,
+      isNew: worktreeInfo.isNew,
+      repoRoot: worktreeInfo.repoRoot,
+      originalHeadCommit: worktreeInfo.originalHeadCommit,
+    };
+
+    // Set module-level session state
+    setCurrentWorktreeSession(session);
+
+    // Update CWD via AIManager
+    const aiManager = context.aiManager;
+    if (aiManager) {
+      aiManager.setWorkdir(worktreeInfo.path);
+    }
+
+    // Also update the container's Workdir entry
+    // (Container is not directly accessible from ToolContext, but AIManager.setWorkdir
+    // handles both its internal field and process.chdir)
+
+    // 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(process.env).filter((e) => e[1] !== undefined),
+            ) as Record<string, string>,
+          },
+        );
+
+        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}`,
+    };
+  },
+};