wave-agent-sdk 0.19.4 → 0.19.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -42,6 +42,7 @@ import { TaskManager } from "./services/taskManager.js";
 import { btw } from "./services/aiService.js";
 import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
 import { supportsVision } from "./utils/modelCapabilities.js";
+import type { WorktreeSession } from "./utils/worktreeSession.js";
 import { parseTaskNotificationXml } from "./utils/notificationXml.js";
 import { InitializationService } from "./services/initializationService.js";
 import { InteractionService } from "./services/interactionService.js";
@@ -298,6 +299,15 @@ export class Agent {
     this.options.callbacks?.onWorkdirChange?.(newCwd);
   }
 
+  /**
+   * Set this session's worktree session state (used by CLI -w startup to inject the
+   * session created before the agent existed). Delegates to AIManager so the state is
+   * stored in this agent's own DI container.
+   */
+  public setWorktreeSession(session: WorktreeSession | null): void {
+    this.aiManager.setWorktreeSession(session);
+  }
+
   /** Get project memory content */
   public get projectMemory(): string {
     const memoryService =
@@ -389,6 +399,27 @@ export class Agent {
     return removed;
   }
 
+  /**
+   * Update a queued message's content by its ID (does not change queue order)
+   * @param id - The ID of the message to update
+   * @param patch - The fields to update
+   * @returns true if the message was updated, false if not found
+   */
+  public updateQueuedMessageById(
+    id: string,
+    patch: {
+      content?: string;
+      images?: Array<{ path: string; mimeType: string }>;
+      type?: "message" | "bang";
+    },
+  ): boolean {
+    const updated = this.messageQueue.updateById(id, patch);
+    if (updated) {
+      this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
+    }
+    return updated;
+  }
+
   /**
    * Unified dequeue trigger — checks state machine before processing.
    * Called from onMessageEnqueued, onLoadingChange(false), and

package/src/managers/aiManager.ts

@@ -26,8 +26,10 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
+import type { BackgroundTaskInfo, SessionCronInfo } from "../types/hooks.js";
 import type { PermissionManager } from "./permissionManager.js";
 import type { SubagentManager } from "./subagentManager.js";
+import type { CronManager } from "./cronManager.js";
 import type { SkillManager } from "./skillManager.js";
 import { buildSystemPrompt } from "../prompts/index.js";
 import {
@@ -36,6 +38,7 @@ import {
   buildExitedPlanModeReminder,
 } from "../prompts/planModeReminders.js";
 import { Container } from "../utils/container.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 import { recoverTruncatedJson } from "../utils/stringUtils.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import type { NotificationQueue } from "./notificationQueue.js";
@@ -49,6 +52,47 @@ import {
   resetTracingState,
 } from "../telemetry/sessionTracing.js";
 import { logOTelEvent } from "../telemetry/events.js";
+import type { BackgroundTask } from "../types/processes.js";
+
+// Truncate text to `max` chars and append a "… [+N chars]" marker when exceeded.
+// Used for background_tasks description/command fields (≤1000 chars per spec FR-063).
+function truncateWithMarker(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + `… [+${text.length - max} chars]`;
+}
+
+// Map a BackgroundTask (from BackgroundTaskManager) to the Stop hook's
+// background_tasks array element shape (aligned with Claude Code v2.1.145+).
+// Conditional fields are populated based on task type:
+//   - shell:    `command`
+//   - subagent: `agent_type` (looked up via SubagentManager by subagentId)
+//   - workflow: `name` (extracted from "Workflow: <name>" description)
+function mapBackgroundTask(
+  task: BackgroundTask,
+  subagentManager: SubagentManager | undefined,
+): BackgroundTaskInfo {
+  const base: BackgroundTaskInfo = {
+    id: task.id,
+    type: task.type,
+    status: task.status,
+    description: truncateWithMarker(task.description ?? "", 1000),
+  };
+  if (task.type === "shell") {
+    return { ...base, command: truncateWithMarker(task.command ?? "", 1000) };
+  }
+  if (task.type === "subagent") {
+    const instance = subagentManager
+      ?.getActiveInstances()
+      .find((i) => i.subagentId === task.subagentId);
+    return { ...base, agent_type: instance?.subagentType ?? "" };
+  }
+  // workflow
+  const prefix = "Workflow: ";
+  const name = task.description?.startsWith(prefix)
+    ? task.description.slice(prefix.length)
+    : (task.description ?? "");
+  return { ...base, name };
+}
 
 export interface AIManagerCallbacks {
   onCompactionStateChange?: (isCompacting: boolean) => void;
@@ -217,11 +261,31 @@ export class AIManager {
 
   /**
    * Update the working directory mid-session (e.g., when entering/exiting a worktree).
-   * Also updates process.chdir() so bash commands use the new directory.
+   * Only updates this session's DI container; it does NOT change the process-level
+   * process.cwd(), so concurrent sessions in the same stdio process are unaffected.
+   * Triggers `_onCwdChange` (wired by Agent to `onWorkdirChange`) so the host is
+   * notified of worktree switches. Unlike bash `cd`, this does NOT run CwdChanged
+   * hooks (worktree has its own WorktreeCreate/WorktreeRemove hooks).
    */
   public setWorkdir(newWorkdir: string): void {
     this.container.register("Workdir", newWorkdir);
-    process.chdir(newWorkdir);
+    this._onCwdChange?.(newWorkdir);
+  }
+
+  /**
+   * Get this session's worktree session state (null if not in a worktree).
+   */
+  public getWorktreeSession(): WorktreeSession | null {
+    return (
+      this.container.get<WorktreeSession | null>("WorktreeSession") ?? null
+    );
+  }
+
+  /**
+   * Set this session's worktree session state.
+   */
+  public setWorktreeSession(session: WorktreeSession | null): void {
+    this.container.register("WorktreeSession", session);
   }
 
   public setOnCwdChange(callback: (newCwd: string) => void): void {
@@ -734,6 +798,10 @@ export class AIManager {
     return this.container.get<SubagentManager>("SubagentManager");
   }
 
+  private get cronManager(): CronManager | undefined {
+    return this.container.get<CronManager>("CronManager");
+  }
+
   private get skillManager(): SkillManager | undefined {
     return this.container.get<SkillManager>("SkillManager");
   }
@@ -895,6 +963,7 @@ export class AIManager {
                 originalWorkdir: this.getOriginalWorkdir(),
                 language: this.getLanguage(),
                 isSubagent: !!this.subagentType,
+                worktreeSession: this.getWorktreeSession(),
                 autoMemory: autoMemoryOptions,
               },
             ), // Pass custom system prompt
@@ -1279,6 +1348,16 @@ export class AIManager {
             message: error instanceof Error ? error.message : String(error),
           }).catch(() => {}); // Non-blocking
 
+          // Finalize any streaming text/reasoning blocks so the UI stops ticking
+          // its in-progress timer (e.g. when the request is aborted mid-thought).
+          this.messageManager.finalizeStreamingBlocks();
+
+          // Finalize any tool blocks stuck in start/streaming/running so the UI
+          // stops showing the yellow "running" spinner (e.g. abort mid-tool-stream).
+          this.messageManager.finalizeAbortedToolBlocks(
+            error instanceof Error ? error.message : undefined,
+          );
+
           this.messageManager.addErrorBlock(
             error instanceof Error ? error.message : "Unknown error occurred",
           );
@@ -1435,6 +1514,40 @@ export class AIManager {
       // Use "SubagentStop" hook name when triggered by a subagent, otherwise use "Stop"
       const hookName = this.subagentType ? "SubagentStop" : "Stop";
 
+      // For main-agent Stop events, snapshot running background tasks and
+      // session cron jobs so the hook can decide whether to block stopping.
+      // SubagentStop does not include these fields (per spec FR-065).
+      const backgroundTasks: BackgroundTaskInfo[] | undefined =
+        hookName === "Stop"
+          ? (this.backgroundTaskManager?.getAllTasks() ?? [])
+              .filter((t) => t.status === "running")
+              .map((t) => mapBackgroundTask(t, this.subagentManager))
+          : undefined;
+
+      const sessionCrons: SessionCronInfo[] | undefined =
+        hookName === "Stop"
+          ? (this.cronManager?.listJobs() ?? []).map((j) => ({
+              id: j.id,
+              schedule: j.cron,
+              recurring: j.recurring,
+              prompt: j.prompt,
+            }))
+          : undefined;
+
+      // Extract text content from the last assistant message so hooks can
+      // inspect the final response without reading the transcript file.
+      const allMessages = this.messageManager.getMessages();
+      const lastAssistant = [...allMessages]
+        .reverse()
+        .find((m) => m.role === "assistant");
+      const lastAssistantText = lastAssistant
+        ? lastAssistant.blocks
+            .filter((b) => b.type === "text")
+            .map((b) => b.content)
+            .join("\n")
+            .trim() || undefined
+        : undefined;
+
       const context: ExtendedHookExecutionContext = {
         event: hookName,
         projectDir: this.getWorkdir(),
@@ -1443,6 +1556,9 @@ export class AIManager {
         transcriptPath: this.messageManager.getTranscriptPath(),
         cwd: this.getWorkdir(),
         subagentType: this.subagentType, // Include subagent type in hook context
+        backgroundTasks, // Stop-only: running background tasks snapshot
+        sessionCrons, // Stop-only: session cron jobs snapshot
+        lastAssistantMessage: lastAssistantText, // Stop/SubagentStop: last assistant message text
         // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
         env: Object.fromEntries(
           Object.entries(process.env).filter((e) => e[1] !== undefined),

package/src/managers/backgroundTaskManager.ts

@@ -7,6 +7,7 @@ import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
 import { NotificationQueue } from "./notificationQueue.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 
 export interface BackgroundTaskManagerCallbacks {
   onBackgroundTasksChange?: (tasks: BackgroundTask[]) => void;
@@ -64,15 +65,16 @@ export class BackgroundTaskManager {
   public startShell(
     command: string,
     timeout?: number,
+    cwd?: string,
   ): { id: string; child: ChildProcess; detach: () => void } {
     const id = this.generateId();
     const startTime = Date.now();
 
     const child = spawn(command, {
-      shell: true,
+      shell: resolveShellPath() ?? true,
       stdio: "pipe",
       detached: true,
-      cwd: this.workdir,
+      cwd: cwd ?? this.workdir,
       env: {
         ...process.env,
       },

package/src/managers/bangManager.ts

@@ -1,6 +1,7 @@
 import { spawn, type ChildProcess } from "child_process";
 import type { MessageManager } from "./messageManager.js";
 import { Container } from "../utils/container.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
 
 export interface BangManagerOptions {
   workdir: string;
@@ -45,7 +46,7 @@ export class BangManager {
 
     return new Promise<number>((resolve) => {
       const child = spawn(command, {
-        shell: true,
+        shell: resolveShellPath() ?? true,
         stdio: "pipe",
         cwd: this.workdir,
         env: {

package/src/managers/messageManager.ts

@@ -16,7 +16,7 @@ import {
   type AddNotificationMessageParams,
   generateMessageId,
 } from "../utils/messageOperations.js";
-import type { Message, Usage } from "../types/index.js";
+import type { Message, Usage, ToolBlock } from "../types/index.js";
 import { getLastApiRounds } from "../utils/groupMessagesByApiRound.js";
 import { join, isAbsolute, relative } from "path";
 import {
@@ -718,12 +718,23 @@ export class MessageManager {
       type: "text" | "reasoning";
       content: string;
       stage?: string;
+      startTime?: number;
     };
-    lastMessage.blocks[index] = {
-      type: block.type,
-      content: block.content,
-      stage: "end" as const,
-    };
+    if (block.type === "reasoning") {
+      lastMessage.blocks[index] = {
+        type: "reasoning",
+        content: block.content,
+        stage: "end" as const,
+        startTime: block.startTime,
+        endTime: Date.now(),
+      };
+    } else {
+      lastMessage.blocks[index] = {
+        type: block.type,
+        content: block.content,
+        stage: "end" as const,
+      };
+    }
 
     // Fire incremental callback to signal finalization
     const callbackParams = {
@@ -832,10 +843,16 @@ export class MessageManager {
 
     if (reasoningBlockIndex >= 0) {
       // Update existing reasoning block
+      const existingStartTime = (
+        lastMessage.blocks[reasoningBlockIndex] as {
+          startTime?: number;
+        }
+      ).startTime;
       lastMessage.blocks[reasoningBlockIndex] = {
         type: "reasoning",
         content: newAccumulatedReasoning,
         stage: "streaming",
+        startTime: existingStartTime,
       };
     } else {
       // Add new reasoning block if none exists
@@ -843,6 +860,7 @@ export class MessageManager {
         type: "reasoning",
         content: newAccumulatedReasoning,
         stage: "streaming",
+        startTime: Date.now(),
       });
     }
 
@@ -878,6 +896,54 @@ export class MessageManager {
     }
   }
 
+  /**
+   * Finalize any tool blocks still in a non-terminal stage (start/streaming/running)
+   * by marking them as ended with an error. Called when the AI call is aborted or
+   * fails mid-tool-stream so the UI stops showing the "running" spinner.
+   * Fires onToolBlockUpdated for each finalized tool block.
+   */
+  public finalizeAbortedToolBlocks(error?: string): void {
+    if (this.messages.length === 0) return;
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage.role !== "assistant") return;
+
+    const errorMessage = error ?? "Tool execution was aborted";
+    let finalized = false;
+
+    for (let i = 0; i < lastMessage.blocks.length; i++) {
+      const block = lastMessage.blocks[i] as ToolBlock;
+      if (block.type !== "tool" || block.stage === "end") continue;
+
+      const timestamp = Date.now();
+      lastMessage.blocks[i] = {
+        ...block,
+        stage: "end",
+        success: false,
+        error: errorMessage,
+        timestamp,
+      };
+      finalized = true;
+
+      this.callbacks.onToolBlockUpdated?.({
+        id: block.id ?? "",
+        messageId: lastMessage.id ?? "",
+        name: block.name,
+        parameters: block.parameters,
+        parametersChunk: block.parametersChunk,
+        compactParams: block.compactParams,
+        stage: "end",
+        success: false,
+        error: errorMessage,
+        isManuallyBackgrounded: block.isManuallyBackgrounded,
+        timestamp,
+      });
+    }
+
+    if (finalized) {
+      this.setMessages([...this.messages]);
+    }
+  }
+
   /**
    * Remove the last user message from the conversation
    * Used for hook error handling when the user prompt needs to be erased

package/src/managers/messageQueue.ts

@@ -74,6 +74,23 @@ export class MessageQueue {
     return true;
   }
 
+  updateById(
+    id: string,
+    patch: {
+      content?: string;
+      images?: Array<{ path: string; mimeType: string }>;
+      type?: "message" | "bang";
+    },
+  ): boolean {
+    const m = this.queue.find((x) => x.id === id);
+    if (!m) return false;
+    if (patch.content !== undefined) m.content = patch.content;
+    if (patch.images !== undefined) m.images = patch.images;
+    if (patch.type !== undefined) m.type = patch.type;
+    this.onMessageEnqueued?.();
+    return true;
+  }
+
   popLastEditable(): QueuedMessage | null {
     for (let i = this.queue.length - 1; i >= 0; i--) {
       if (this.queue[i].editable !== false) {

package/src/managers/permissionManager.ts

@@ -35,7 +35,7 @@ import {
 } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
 import { ConfigurationService } from "../services/configurationService.js";
-import { getCurrentWorktreeSession } from "../utils/worktreeSession.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 
 const SAFE_COMMANDS = [
   "cd",
@@ -452,8 +452,11 @@ export class PermissionManager {
     }
 
     // 1.0 Check worktree safety for Write and Edit tools
-    // Support both CLI -w sessions (container-registered) and EnterWorktree mid-session (module-level)
-    const worktreeSession = getCurrentWorktreeSession();
+    // Support both CLI -w sessions (container-registered) and EnterWorktree mid-session
+    // (per-agent WorktreeSession stored in this session's container)
+    const worktreeSession = this.container.get<WorktreeSession | null>(
+      "WorktreeSession",
+    );
     const effectiveWorktreeName =
       this.worktreeName || worktreeSession?.worktreeName;
     const effectiveWorkdir = this.workdir || worktreeSession?.worktreePath;

package/src/managers/subagentManager.ts

@@ -7,7 +7,13 @@ import type { Message, Usage } from "../types/index.js";
 import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
-import { AGENT_TOOL_NAME } from "../constants/tools.js";
+import {
+  AGENT_TOOL_NAME,
+  TASK_CREATE_TOOL_NAME,
+  TASK_GET_TOOL_NAME,
+  TASK_LIST_TOOL_NAME,
+  TASK_UPDATE_TOOL_NAME,
+} from "../constants/tools.js";
 import {
   addConsolidatedAbortListener,
   createAbortPromise,
@@ -321,6 +327,12 @@ export class SubagentManager {
       instanceDeniedRules: [
         ...(parentPermissionManager?.getInstanceDeniedRules?.() || []),
         AGENT_TOOL_NAME, // Always deny Agent tool in subagents to prevent recursion
+        // Deny Task tools in subagents — they share the parent's TaskManager
+        // and could mutate the main agent's task list
+        TASK_CREATE_TOOL_NAME,
+        TASK_GET_TOOL_NAME,
+        TASK_UPDATE_TOOL_NAME,
+        TASK_LIST_TOOL_NAME,
       ],
       additionalDirectories:
         parentPermissionManager?.getAdditionalDirectories(),

package/src/prompts/index.ts

@@ -1,7 +1,7 @@
 import * as os from "node:os";
 import { ToolPlugin } from "../tools/types.js";
 import { isGitRepository } from "../utils/gitUtils.js";
-import { getCurrentWorktreeSession } from "../utils/worktreeSession.js";
+import type { WorktreeSession } from "../utils/worktreeSession.js";
 import { buildAutoMemoryPrompt } from "./autoMemory.js";
 import {
   EXPLORE_SUBAGENT_TYPE,
@@ -252,6 +252,7 @@ export function buildSystemPrompt(
     originalWorkdir?: string;
     language?: string;
     isSubagent?: boolean;
+    worktreeSession?: WorktreeSession | null;
     autoMemory?: {
       directory: string;
       content: string;
@@ -292,7 +293,7 @@ export function buildSystemPrompt(
         ? "bash"
         : shell;
 
-    const worktreeSession = getCurrentWorktreeSession();
+    const worktreeSession = options.worktreeSession;
 
     dynamicText += `
 
@@ -326,6 +327,7 @@ export function enhanceSystemPromptWithEnvDetails(
   existingSystemPrompt: string,
   workdir: string,
   originalWorkdir?: string,
+  worktreeSession?: WorktreeSession | null,
 ): string {
   const isGitRepo = isGitRepository(workdir);
   const platform = os.platform();
@@ -338,8 +340,6 @@ export function enhanceSystemPromptWithEnvDetails(
       ? "bash"
       : shell;
 
-  const worktreeSession = getCurrentWorktreeSession();
-
   const notes = `Notes:
 - Agent threads always have their cwd reset between bash calls, as a result please only use absolute file paths.${worktreeSession ? `\n- You are in a git worktree at ${worktreeSession.worktreePath} (branch: ${worktreeSession.worktreeBranch}). Absolute paths from prior context may refer to the original repo at ${worktreeSession.originalCwd}; translate them to your worktree. Do NOT edit files outside this worktree.` : ""}
 - In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing (e.g., a bug you found, a function signature the caller asked for) — do not recap code you merely read.

package/src/services/hook.ts

@@ -113,6 +113,22 @@ async function buildHookJsonInput(
     }
   }
 
+  // Add background_tasks and session_crons for Stop events only (not SubagentStop).
+  // Fields are always present for Stop (empty arrays when nothing in flight).
+  if (context.event === "Stop") {
+    jsonInput.background_tasks = context.backgroundTasks ?? [];
+    jsonInput.session_crons = context.sessionCrons ?? [];
+  }
+
+  // Add last_assistant_message for Stop and SubagentStop events.
+  // Omitted when undefined (no text content in last assistant message).
+  if (
+    (context.event === "Stop" || context.event === "SubagentStop") &&
+    context.lastAssistantMessage !== undefined
+  ) {
+    jsonInput.last_assistant_message = context.lastAssistantMessage;
+  }
+
   return jsonInput;
 }
 

package/src/tools/bashTool.ts

@@ -173,14 +173,16 @@ The working directory persists between commands. Try to maintain your current wo
       };
     }
 
-    // Resolve shell path: on Windows, use Git Bash; on other platforms, use default
+    // Resolve shell path: on Windows, use Git Bash; on macOS/Linux, use bash or zsh
     const shellPath = resolveShellPath();
-    if (process.platform === "win32" && !shellPath) {
+    if (!shellPath) {
       return {
         success: false,
         content: "",
         error:
-          "Git Bash not found. Please install Git for Windows or set GIT_BASH_PATH environment variable.",
+          process.platform === "win32"
+            ? "Git Bash not found. Please install Git for Windows or set WAVE_GIT_BASH_PATH environment variable."
+            : "No suitable shell found. Please ensure bash or zsh is installed, or set WAVE_SHELL environment variable.",
       };
     }
 
@@ -242,7 +244,11 @@ The working directory persists between commands. Try to maintain your current wo
         };
       }
 
-      const { id: taskId } = backgroundTaskManager.startShell(command);
+      const { id: taskId } = backgroundTaskManager.startShell(
+        command,
+        undefined,
+        context.workdir,
+      );
       const task = backgroundTaskManager.getTask(taskId);
       const outputPath = task?.outputPath;
       const backgroundMsg = [
@@ -273,7 +279,7 @@ The working directory persists between commands. Try to maintain your current wo
       );
 
       const child: ChildProcess = spawn(wrappedCommand, {
-        shell: shellPath || true,
+        shell: shellPath,
         stdio: "pipe",
         detached: true,
         cwd: context.workdir,

package/src/tools/enterWorktreeTool.ts

@@ -4,11 +4,7 @@
  */
 
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import {
-  getCurrentWorktreeSession,
-  setCurrentWorktreeSession,
-  type WorktreeSession,
-} from "../utils/worktreeSession.js";
+import { type WorktreeSession } from "../utils/worktreeSession.js";
 import {
   createWorktree,
   validateWorktreeName,
@@ -72,7 +68,7 @@ export const enterWorktreeTool: ToolPlugin = {
     context: ToolContext,
   ): Promise<ToolResult> {
     // Validate not already in a worktree created by this session
-    if (getCurrentWorktreeSession()) {
+    if (context.aiManager?.getWorktreeSession()) {
       return {
         success: false,
         content:
@@ -119,19 +115,13 @@ export const enterWorktreeTool: ToolPlugin = {
       originalHeadCommit: worktreeInfo.originalHeadCommit,
     };
 
-    // Set module-level session state
-    setCurrentWorktreeSession(session);
-
-    // Update CWD via AIManager
+    // Set per-session worktree state and update CWD via AIManager
     const aiManager = context.aiManager;
     if (aiManager) {
+      aiManager.setWorktreeSession(session);
       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) {