wave-code 0.19.9 → 1.0.0

package/dist/managers/inputReducer.js

@@ -1,5 +1,6 @@
 import { getAtSelectorPosition, getSlashSelectorPosition, getWordEnd, SELECTOR_TRIGGERS, getProjectedState, } from "../utils/inputUtils.js";
 import { AVAILABLE_COMMANDS } from "../constants/commands.js";
+export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 export const initialState = {
     inputText: "",
     cursorPosition: 0,
@@ -27,9 +28,6 @@ export const initialState = {
     showWorkflowManager: false,
     permissionMode: "default",
     selectorJustUsed: false,
-    isPasting: false,
-    pasteBuffer: "",
-    initialPasteCursorPosition: 0,
     history: [],
     historyIndex: -1,
     originalInputText: "",
@@ -40,7 +38,146 @@ export const initialState = {
         isLoading: false,
     },
     pendingEffect: null,
+    escClearPending: false,
 };
+/**
+ * Insert text at the cursor position, folding text longer than 200 chars
+ * into a [LongText#N] placeholder. Shared by the INSERT_TEXT_WITH_PLACEHOLDER
+ * action and multi-char chunk inserts (typed bursts, terminal paste, tmux
+ * send-keys).
+ */
+function insertTextWithPlaceholder(textToInsert, state) {
+    let text = textToInsert;
+    let newLongTextCounter = state.longTextCounter;
+    const newLongTextMap = { ...state.longTextMap };
+    if (text.length > 200) {
+        newLongTextCounter += 1;
+        const placeholderLabel = `[LongText#${newLongTextCounter}]`;
+        newLongTextMap[placeholderLabel] = text;
+        text = placeholderLabel;
+    }
+    const beforeCursor = state.inputText.substring(0, state.cursorPosition);
+    const afterCursor = state.inputText.substring(state.cursorPosition);
+    const newText = beforeCursor + text + afterCursor;
+    const newCursorPosition = state.cursorPosition + text.length;
+    const newState = {
+        ...state,
+        inputText: newText,
+        cursorPosition: newCursorPosition,
+        longTextCounter: newLongTextCounter,
+        longTextMap: newLongTextMap,
+        historyIndex: -1,
+    };
+    // Sync selectors
+    const atPos = getAtSelectorPosition(newText, newCursorPosition);
+    if (atPos !== -1 && !newState.showFileSelector) {
+        newState.showFileSelector = true;
+        newState.atPosition = atPos;
+        newState.isFileSearching = true;
+    }
+    const slashPos = getSlashSelectorPosition(newText, newCursorPosition);
+    if (slashPos !== -1 && !newState.showCommandSelector) {
+        newState.showCommandSelector = true;
+        newState.slashPosition = slashPos;
+    }
+    if (newState.showFileSelector && newState.atPosition >= 0) {
+        newState.fileSearchQuery = newText.substring(newState.atPosition + 1, newCursorPosition);
+    }
+    else if (newState.showCommandSelector && newState.slashPosition >= 0) {
+        newState.commandSearchQuery = newText.substring(newState.slashPosition + 1, newCursorPosition);
+    }
+    return newState;
+}
+/**
+ * Submit the current input text: extract [Image #N] references, route /btw
+ * and CLI-internal slash commands, otherwise send as a message. Returns null
+ * when there is nothing to submit (empty text, bare /btw).
+ */
+function submitInput(state) {
+    if (!state.inputText.trim()) {
+        return null;
+    }
+    const imageRegex = /\[Image #(\d+)\]/g;
+    const matches = [...state.inputText.matchAll(imageRegex)];
+    const referencedImages = matches
+        .map((match) => {
+        const imageId = parseInt(match[1], 10);
+        return state.attachedImages.find((img) => img.id === imageId);
+    })
+        .filter((img) => img !== undefined)
+        .map((img) => ({ path: img.path, mimeType: img.mimeType }));
+    const contentWithPlaceholders = state.inputText
+        .replace(imageRegex, "")
+        .trim();
+    if (contentWithPlaceholders.startsWith("/btw ")) {
+        const question = contentWithPlaceholders.substring(5).trim();
+        if (!question) {
+            // Bare /btw with no question text — ignore
+            return null;
+        }
+        return {
+            ...state,
+            inputText: "",
+            cursorPosition: 0,
+            historyIndex: -1,
+            longTextMap: {},
+            attachedImages: [],
+            btwState: {
+                question,
+                isLoading: true,
+                answer: undefined,
+            },
+            pendingEffect: { type: "ASK_BTW", question },
+        };
+    }
+    if (contentWithPlaceholders === "/btw") {
+        // Bare /btw — ignore
+        return null;
+    }
+    // Check if the content is a CLI-internal slash command (help, tasks,
+    // etc.) that should be executed locally rather than sent as a message.
+    // Agent slash commands and unknown /commands always go to SEND_MESSAGE.
+    if (contentWithPlaceholders.startsWith("/")) {
+        const spaceIndex = contentWithPlaceholders.indexOf(" ");
+        const commandName = spaceIndex === -1
+            ? contentWithPlaceholders.substring(1)
+            : contentWithPlaceholders.substring(1, spaceIndex);
+        const isInternalCommand = AVAILABLE_COMMANDS.some((cmd) => cmd.id === commandName);
+        if (isInternalCommand) {
+            const argsText = spaceIndex === -1
+                ? undefined
+                : contentWithPlaceholders.substring(spaceIndex + 1).trim() ||
+                    undefined;
+            return {
+                ...state,
+                inputText: "",
+                cursorPosition: 0,
+                historyIndex: -1,
+                longTextMap: {},
+                attachedImages: [],
+                pendingEffect: {
+                    type: "EXECUTE_COMMAND",
+                    command: commandName,
+                    args: argsText,
+                },
+            };
+        }
+    }
+    return {
+        ...state,
+        inputText: "",
+        cursorPosition: 0,
+        historyIndex: -1,
+        longTextMap: {},
+        attachedImages: [],
+        pendingEffect: {
+            type: "SEND_MESSAGE",
+            content: contentWithPlaceholders,
+            images: referencedImages.length > 0 ? referencedImages : undefined,
+            longTextMap: state.longTextMap,
+        },
+    };
+}
 export function inputReducer(state, action) {
     switch (action.type) {
         case "SET_INPUT_TEXT":
@@ -225,48 +362,8 @@ export function inputReducer(state, action) {
             return { ...state, permissionMode: action.payload };
         case "SET_SELECTOR_JUST_USED":
             return { ...state, selectorJustUsed: action.payload };
-        case "INSERT_TEXT_WITH_PLACEHOLDER": {
-            let textToInsert = action.payload;
-            let newLongTextCounter = state.longTextCounter;
-            const newLongTextMap = { ...state.longTextMap };
-            if (textToInsert.length > 200) {
-                newLongTextCounter += 1;
-                const placeholderLabel = `[LongText#${newLongTextCounter}]`;
-                newLongTextMap[placeholderLabel] = textToInsert;
-                textToInsert = placeholderLabel;
-            }
-            const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-            const afterCursor = state.inputText.substring(state.cursorPosition);
-            const newText = beforeCursor + textToInsert + afterCursor;
-            const newCursorPosition = state.cursorPosition + textToInsert.length;
-            const newState = {
-                ...state,
-                inputText: newText,
-                cursorPosition: newCursorPosition,
-                longTextCounter: newLongTextCounter,
-                longTextMap: newLongTextMap,
-                historyIndex: -1,
-            };
-            // Sync selectors
-            const atPos = getAtSelectorPosition(newText, newCursorPosition);
-            if (atPos !== -1 && !newState.showFileSelector) {
-                newState.showFileSelector = true;
-                newState.atPosition = atPos;
-                newState.isFileSearching = true;
-            }
-            const slashPos = getSlashSelectorPosition(newText, newCursorPosition);
-            if (slashPos !== -1 && !newState.showCommandSelector) {
-                newState.showCommandSelector = true;
-                newState.slashPosition = slashPos;
-            }
-            if (newState.showFileSelector && newState.atPosition >= 0) {
-                newState.fileSearchQuery = newText.substring(newState.atPosition + 1, newCursorPosition);
-            }
-            else if (newState.showCommandSelector && newState.slashPosition >= 0) {
-                newState.commandSearchQuery = newText.substring(newState.slashPosition + 1, newCursorPosition);
-            }
-            return newState;
-        }
+        case "INSERT_TEXT_WITH_PLACEHOLDER":
+            return insertTextWithPlaceholder(action.payload, state);
         case "CLEAR_LONG_TEXT_MAP":
             return { ...state, longTextMap: {} };
         case "CLEAR_INPUT":
@@ -276,39 +373,6 @@ export function inputReducer(state, action) {
                 cursorPosition: 0,
                 historyIndex: -1,
             };
-        case "APPEND_PASTE_CHUNK": {
-            // The reducer determines if this is a new paste or a continuation
-            // by checking if pasteBuffer is already set. This avoids the
-            // handler needing to track isPasting state, which can be stale
-            // when multiple dispatches fire before React state updates.
-            const isNewPaste = !state.pasteBuffer;
-            return {
-                ...state,
-                isPasting: true,
-                pasteBuffer: state.pasteBuffer + action.payload.chunk,
-                initialPasteCursorPosition: isNewPaste
-                    ? action.payload.cursorPosition
-                    : state.initialPasteCursorPosition,
-            };
-        }
-        case "START_PASTE":
-            return {
-                ...state,
-                isPasting: true,
-                pasteBuffer: action.payload.buffer,
-                initialPasteCursorPosition: action.payload.cursorPosition,
-            };
-        case "APPEND_PASTE_BUFFER":
-            return {
-                ...state,
-                pasteBuffer: state.pasteBuffer + action.payload,
-            };
-        case "END_PASTE":
-            return {
-                ...state,
-                isPasting: false,
-                pasteBuffer: "",
-            };
         case "ADD_IMAGE_AND_INSERT_PLACEHOLDER": {
             const newImage = {
                 id: state.imageIdCounter,
@@ -462,9 +526,73 @@ export function inputReducer(state, action) {
             };
         case "CLEAR_PENDING_EFFECT":
             return { ...state, pendingEffect: null };
+        case "RESET_ESC_CLEAR_PENDING":
+            return { ...state, escClearPending: false };
         case "HANDLE_KEY": {
             const { input, key } = action.payload;
             const hasQueuedMessages = action.payload.hasQueuedMessages ?? false;
+            const isIdle = action.payload.isIdle ?? false;
+            // 0. Raw DEL (\x7f) filtering.
+            // SSH/tmux auto-repeat backspace coalesces multiple DEL bytes into one
+            // chunk (e.g. "\x7f\x7f") that ink cannot parse into a key event, so it
+            // arrives as raw input and would otherwise be treated as a paste and
+            // inserted literally. Treat each DEL as a synchronous backspace instead
+            // (aligned with Claude Code Issue #1853).
+            if (!key.backspace && !key.delete && input.includes("\x7f")) {
+                const delCount = (input.match(/\x7f/g) || []).length;
+                if (state.showHistorySearch) {
+                    return {
+                        ...state,
+                        historySearchQuery: state.historySearchQuery.slice(0, -delCount),
+                    };
+                }
+                if (state.cursorPosition > 0) {
+                    const newCursorPosition = Math.max(0, state.cursorPosition - delCount);
+                    const newInputText = state.inputText.substring(0, newCursorPosition) +
+                        state.inputText.substring(state.cursorPosition);
+                    const newState = {
+                        ...state,
+                        inputText: newInputText,
+                        cursorPosition: newCursorPosition,
+                        historyIndex: -1,
+                    };
+                    // Deactivate selectors if their trigger character was deleted
+                    if (newState.showFileSelector &&
+                        newCursorPosition <= newState.atPosition) {
+                        newState.showFileSelector = false;
+                        newState.atPosition = -1;
+                        newState.fileSearchQuery = "";
+                        newState.isFileSearching = false;
+                    }
+                    if (newState.showCommandSelector &&
+                        newCursorPosition <= newState.slashPosition) {
+                        newState.showCommandSelector = false;
+                        newState.slashPosition = -1;
+                        newState.commandSearchQuery = "";
+                    }
+                    // Reactivate selectors if cursor is within a trigger word
+                    const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+                    if (atPos !== -1 && !state.showFileSelector) {
+                        newState.showFileSelector = true;
+                        newState.atPosition = atPos;
+                        newState.isFileSearching = true;
+                    }
+                    const slashPos = getSlashSelectorPosition(newInputText, newCursorPosition);
+                    if (slashPos !== -1 && !state.showCommandSelector) {
+                        newState.showCommandSelector = true;
+                        newState.slashPosition = slashPos;
+                    }
+                    // Update queries
+                    if (newState.showFileSelector && newState.atPosition >= 0) {
+                        newState.fileSearchQuery = newInputText.substring(newState.atPosition + 1, newCursorPosition);
+                    }
+                    if (newState.showCommandSelector && newState.slashPosition >= 0) {
+                        newState.commandSearchQuery = newInputText.substring(newState.slashPosition + 1, newCursorPosition);
+                    }
+                    return newState;
+                }
+                return state;
+            }
             // 1. Escape Handling
             if (key.escape) {
                 // Dismiss btw answer
@@ -526,7 +654,39 @@ export function inputReducer(state, action) {
                     state.showPluginManager ||
                     state.showModelSelector ||
                     state.showWorkflowManager)) {
-                    return { ...state, pendingEffect: { type: "ABORT_MESSAGE" } };
+                    // While AI is running (or any busy state) Esc keeps the abort
+                    // semantics. Only when idle does Esc fall through to the text-level
+                    // double-press clear (aligned with Claude Code's mutual-exclusion
+                    // design: Esc aborts only when a task is running).
+                    if (!isIdle) {
+                        return {
+                            ...state,
+                            escClearPending: false,
+                            pendingEffect: { type: "ABORT_MESSAGE" },
+                        };
+                    }
+                    // Idle: double-press Esc clears the input and saves to history.
+                    if (state.inputText) {
+                        if (state.escClearPending) {
+                            const originalText = state.inputText;
+                            const originalLongTextMap = state.longTextMap;
+                            return {
+                                ...state,
+                                inputText: "",
+                                cursorPosition: 0,
+                                historyIndex: -1,
+                                longTextMap: {},
+                                escClearPending: false,
+                                pendingEffect: {
+                                    type: "SAVE_PROMPT_HISTORY",
+                                    content: originalText,
+                                    longTextMap: originalLongTextMap,
+                                },
+                            };
+                        }
+                        return { ...state, escClearPending: true };
+                    }
+                    return state;
                 }
                 return state;
             }
@@ -563,6 +723,55 @@ export function inputReducer(state, action) {
                     pendingEffect: { type: "BACKGROUND_CURRENT_TASK" },
                 };
             }
+            // Emacs-style line editing (aligned with Claude Code): Ctrl+A/E move the
+            // cursor to line start/end, Ctrl+U/K delete to line start/end, Ctrl+W
+            // deletes the word before the cursor. Skipped while a selector is open.
+            if (key.ctrl &&
+                input &&
+                !state.showFileSelector &&
+                !state.showCommandSelector &&
+                !state.showHistorySearch) {
+                const editKey = input.toLowerCase();
+                if (editKey === "a") {
+                    return { ...state, cursorPosition: 0 };
+                }
+                if (editKey === "e") {
+                    return { ...state, cursorPosition: state.inputText.length };
+                }
+                if (editKey === "u") {
+                    return {
+                        ...state,
+                        inputText: state.inputText.substring(state.cursorPosition),
+                        cursorPosition: 0,
+                        historyIndex: -1,
+                    };
+                }
+                if (editKey === "k") {
+                    return {
+                        ...state,
+                        inputText: state.inputText.substring(0, state.cursorPosition),
+                        historyIndex: -1,
+                    };
+                }
+                if (editKey === "w") {
+                    // Find the start of the word before the cursor (skip trailing
+                    // whitespace, then the word itself).
+                    let start = state.cursorPosition - 1;
+                    while (start >= 0 && /\s/.test(state.inputText[start])) {
+                        start--;
+                    }
+                    while (start >= 0 && !/\s/.test(state.inputText[start])) {
+                        start--;
+                    }
+                    return {
+                        ...state,
+                        inputText: state.inputText.substring(0, start + 1) +
+                            state.inputText.substring(state.cursorPosition),
+                        cursorPosition: start + 1,
+                        historyIndex: -1,
+                    };
+                }
+            }
             // 4. History Navigation
             if (key.upArrow &&
                 !state.showFileSelector &&
@@ -713,89 +922,7 @@ export function inputReducer(state, action) {
             }
             // 6. Return / Submit
             if (key.return) {
-                if (state.inputText.trim()) {
-                    const imageRegex = /\[Image #(\d+)\]/g;
-                    const matches = [...state.inputText.matchAll(imageRegex)];
-                    const referencedImages = matches
-                        .map((match) => {
-                        const imageId = parseInt(match[1], 10);
-                        return state.attachedImages.find((img) => img.id === imageId);
-                    })
-                        .filter((img) => img !== undefined)
-                        .map((img) => ({ path: img.path, mimeType: img.mimeType }));
-                    const contentWithPlaceholders = state.inputText
-                        .replace(imageRegex, "")
-                        .trim();
-                    if (contentWithPlaceholders.startsWith("/btw ")) {
-                        const question = contentWithPlaceholders.substring(5).trim();
-                        if (!question) {
-                            // Bare /btw with no question text — ignore
-                            return state;
-                        }
-                        return {
-                            ...state,
-                            inputText: "",
-                            cursorPosition: 0,
-                            historyIndex: -1,
-                            longTextMap: {},
-                            attachedImages: [],
-                            btwState: {
-                                question,
-                                isLoading: true,
-                                answer: undefined,
-                            },
-                            pendingEffect: { type: "ASK_BTW", question },
-                        };
-                    }
-                    if (contentWithPlaceholders === "/btw") {
-                        // Bare /btw — ignore
-                        return state;
-                    }
-                    // Check if the content is a CLI-internal slash command (help, tasks,
-                    // etc.) that should be executed locally rather than sent as a message.
-                    // Agent slash commands and unknown /commands always go to SEND_MESSAGE.
-                    if (contentWithPlaceholders.startsWith("/")) {
-                        const spaceIndex = contentWithPlaceholders.indexOf(" ");
-                        const commandName = spaceIndex === -1
-                            ? contentWithPlaceholders.substring(1)
-                            : contentWithPlaceholders.substring(1, spaceIndex);
-                        const isInternalCommand = AVAILABLE_COMMANDS.some((cmd) => cmd.id === commandName);
-                        if (isInternalCommand) {
-                            const argsText = spaceIndex === -1
-                                ? undefined
-                                : contentWithPlaceholders.substring(spaceIndex + 1).trim() ||
-                                    undefined;
-                            return {
-                                ...state,
-                                inputText: "",
-                                cursorPosition: 0,
-                                historyIndex: -1,
-                                longTextMap: {},
-                                attachedImages: [],
-                                pendingEffect: {
-                                    type: "EXECUTE_COMMAND",
-                                    command: commandName,
-                                    args: argsText,
-                                },
-                            };
-                        }
-                    }
-                    return {
-                        ...state,
-                        inputText: "",
-                        cursorPosition: 0,
-                        historyIndex: -1,
-                        longTextMap: {},
-                        attachedImages: [],
-                        pendingEffect: {
-                            type: "SEND_MESSAGE",
-                            content: contentWithPlaceholders,
-                            images: referencedImages.length > 0 ? referencedImages : undefined,
-                            longTextMap: state.longTextMap,
-                        },
-                    };
-                }
-                return state;
+                return submitInput(state) ?? state;
             }
             // 7. Regular Input
             if (input &&
@@ -808,17 +935,26 @@ export function inputReducer(state, action) {
                 !key.rightArrow &&
                 !("home" in key && key.home) &&
                 !("end" in key && key.end)) {
-                const isPasteOperation = input.length > 1 || input.includes("\n") || input.includes("\r");
-                if (isPasteOperation) {
-                    const isNewPaste = !state.pasteBuffer;
-                    return {
-                        ...state,
-                        isPasting: true,
-                        pasteBuffer: state.pasteBuffer + input,
-                        initialPasteCursorPosition: isNewPaste
-                            ? state.cursorPosition
-                            : state.initialPasteCursorPosition,
-                    };
+                // SSH-coalesced Enter: on slow links, "text" + Enter arrive as one
+                // chunk ("o\r"). ink's parseKeypress only matches a lone \r, so
+                // key.return is false here. Text with exactly one trailing \r is a
+                // coalesced Enter — strip the \r, insert, and submit immediately
+                // (aligned with Claude Code's useTextInput).
+                const isCoalescedEnter = input.length > 1 &&
+                    input.endsWith("\r") &&
+                    !input.slice(0, -1).includes("\r") &&
+                    // Backslash+CR is a stale VS Code Shift+Enter binding, not a
+                    // coalesced Enter — keep it as regular input.
+                    input[input.length - 2] !== "\\";
+                if (isCoalescedEnter) {
+                    const insertedState = insertTextWithPlaceholder(input.slice(0, -1), state);
+                    return submitInput(insertedState) ?? insertedState;
+                }
+                if (input.length > 1) {
+                    // Multi-char chunk (typed burst, terminal paste, tmux send-keys):
+                    // insert immediately — no debounce or paste buffer. \r → \n
+                    // normalizes carriage returns from CRLF terminals.
+                    return insertTextWithPlaceholder(input.replace(/\r/g, "\n"), state);
                 }
                 else {
                     let char = input;

package/dist/print-cli.js

@@ -1,4 +1,4 @@
-import { Agent, hasUncommittedChanges, hasNewCommits, getDefaultRemoteBranch, } from "wave-agent-sdk";
+import { Agent, hasUncommittedChanges, hasNewCommits, getDefaultRemoteBranch, validateWorktreeRemovalPath, } from "wave-agent-sdk";
 import { displayUsageSummary } from "./utils/usageSummary.js";
 import { removeWorktree } from "./utils/worktree.js";
 function displayTimingInfo(startTime, showStats) {
@@ -129,21 +129,35 @@ export async function startPrintCli(options) {
         }
         // Display timing information
         displayTimingInfo(startTime, showStats);
-        // Destroy agent and exit after sendMessage completes
-        await agent.destroy();
-        // Handle worktree cleanup for print mode
+        // Trigger WorktreeRemove hook (before destroy — it needs a live agent) and
+        // decide whether the worktree is clean enough to remove
+        let cleanWorktree = false;
         if (worktreeSession) {
             const cwd = workdir || worktreeSession.path;
             const baseBranch = getDefaultRemoteBranch(cwd);
             const hasChanges = hasUncommittedChanges(cwd);
             const hasCommits = hasNewCommits(cwd, baseBranch);
-            if (!hasChanges && !hasCommits) {
-                await removeWorktree(worktreeSession);
+            cleanWorktree = !hasChanges && !hasCommits;
+            if (cleanWorktree) {
+                await agent.triggerWorktreeRemoveHook(worktreeSession.path);
             }
             else {
                 process.stdout.write(`\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`);
             }
         }
+        // Destroy agent and exit after sendMessage completes
+        await agent.destroy();
+        // Handle worktree cleanup for print mode (git removal stays after destroy)
+        if (worktreeSession && cleanWorktree) {
+            try {
+                validateWorktreeRemovalPath(worktreeSession.path, worktreeSession.repoRoot);
+                await removeWorktree(worktreeSession);
+            }
+            catch (error) {
+                // Never block print-mode exit on worktree cleanup failures
+                process.stdout.write(`\n⚠️ Skipping worktree removal: ${error.message}\n`);
+            }
+        }
         process.exit(0);
     }
     catch (error) {
@@ -162,20 +176,32 @@ export async function startPrintCli(options) {
             }
             // Display timing information even on error
             displayTimingInfo(startTime, showStats);
-            await agent.destroy();
-            // Handle worktree cleanup for print mode even on error
+            // Trigger WorktreeRemove hook (before destroy) when the worktree is clean
+            let cleanWorktree = false;
             if (worktreeSession) {
                 const cwd = workdir || worktreeSession.path;
                 const baseBranch = getDefaultRemoteBranch(cwd);
                 const hasChanges = hasUncommittedChanges(cwd);
                 const hasCommits = hasNewCommits(cwd, baseBranch);
-                if (!hasChanges && !hasCommits) {
-                    await removeWorktree(worktreeSession);
+                cleanWorktree = !hasChanges && !hasCommits;
+                if (cleanWorktree) {
+                    await agent.triggerWorktreeRemoveHook(worktreeSession.path);
                 }
                 else {
                     process.stdout.write(`\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`);
                 }
             }
+            await agent.destroy();
+            // Handle worktree cleanup for print mode even on error
+            if (worktreeSession && cleanWorktree) {
+                try {
+                    validateWorktreeRemovalPath(worktreeSession.path, worktreeSession.repoRoot);
+                    await removeWorktree(worktreeSession);
+                }
+                catch (error) {
+                    process.stdout.write(`\n⚠️ Skipping worktree removal: ${error.message}\n`);
+                }
+            }
         }
         process.exit(1);
     }