cortex-agents 2.2.0 → 2.3.0

package/dist/tools/worktree.js

@@ -2,57 +2,88 @@ import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
 import { propagatePlan } from "../utils/propagate.js";
+import { git, which, kill, spawn as shellSpawn } from "../utils/shell.js";
+import { detectDriver, closeSession, writeSession, readSession, } from "../utils/terminal.js";
 const WORKTREE_ROOT = ".worktrees";
-export const create = tool({
-    description: "Create a new git worktree for isolated development. Worktrees are created in .worktrees/ at the project root.",
-    args: {
-        name: tool.schema
-            .string()
-            .describe("Worktree name (e.g., 'auth-feature', 'login-bugfix')"),
-        type: tool.schema
-            .enum(["feature", "bugfix", "hotfix", "refactor", "spike", "docs", "test"])
-            .describe("Type of work - determines branch prefix"),
-    },
-    async execute(args, context) {
-        const { name, type } = args;
-        const branchName = `${type}/${name}`;
-        const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
-        const absoluteWorktreePath = path.resolve(worktreePath);
-        // Check if we're in a git repository
-        try {
-            const gitCheck = await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
-            if (!gitCheck.trim()) {
-                return "✗ Error: Not in a git repository";
+/**
+ * Factory function that creates the worktree_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export function createCreate(client) {
+    return tool({
+        description: "Create a new git worktree for isolated development. Worktrees are created in .worktrees/ at the project root.",
+        args: {
+            name: tool.schema
+                .string()
+                .describe("Worktree name (e.g., 'auth-feature', 'login-bugfix')"),
+            type: tool.schema
+                .enum(["feature", "bugfix", "hotfix", "refactor", "spike", "docs", "test"])
+                .describe("Type of work - determines branch prefix"),
+        },
+        async execute(args, context) {
+            const { name, type } = args;
+            const branchName = `${type}/${name}`;
+            const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+            const absoluteWorktreePath = path.resolve(worktreePath);
+            // Check if we're in a git repository
+            try {
+                await git(context.worktree, "rev-parse", "--git-dir");
             }
-        }
-        catch {
-            return "✗ Error: Not in a git repository. Initialize git first.";
-        }
-        // Check if worktree already exists
-        if (fs.existsSync(absoluteWorktreePath)) {
-            return `✗ Error: Worktree already exists at ${absoluteWorktreePath}
+            catch {
+                return "✗ Error: Not in a git repository. Initialize git first.";
+            }
+            // Check if worktree already exists
+            if (fs.existsSync(absoluteWorktreePath)) {
+                return `✗ Error: Worktree already exists at ${absoluteWorktreePath}
 
 Use worktree_list to see existing worktrees.`;
-        }
-        // Create parent directory if needed
-        const worktreeParent = path.dirname(absoluteWorktreePath);
-        if (!fs.existsSync(worktreeParent)) {
-            fs.mkdirSync(worktreeParent, { recursive: true });
-        }
-        // Create the worktree with a new branch
-        try {
-            await Bun.$ `git worktree add -b ${branchName} ${absoluteWorktreePath}`.cwd(context.worktree);
-        }
-        catch (error) {
-            // Branch might already exist, try without -b
+            }
+            // Create parent directory if needed
+            const worktreeParent = path.dirname(absoluteWorktreePath);
+            if (!fs.existsSync(worktreeParent)) {
+                fs.mkdirSync(worktreeParent, { recursive: true });
+            }
+            // Create the worktree with a new branch
             try {
-                await Bun.$ `git worktree add ${absoluteWorktreePath} ${branchName}`.cwd(context.worktree);
+                await git(context.worktree, "worktree", "add", "-b", branchName, absoluteWorktreePath);
             }
-            catch (error2) {
-                return `✗ Error creating worktree: ${error2.message || error2}`;
+            catch {
+                // Branch might already exist, try without -b
+                try {
+                    await git(context.worktree, "worktree", "add", absoluteWorktreePath, branchName);
+                }
+                catch (error2) {
+                    try {
+                        await client.tui.showToast({
+                            body: {
+                                title: `Worktree: ${name}`,
+                                message: `Failed to create: ${error2.message || error2}`,
+                                variant: "error",
+                                duration: 8000,
+                            },
+                        });
+                    }
+                    catch {
+                        // Toast failure is non-fatal
+                    }
+                    return `✗ Error creating worktree: ${error2.message || error2}`;
+                }
             }
-        }
-        return `✓ Created worktree successfully
+            // Notify via toast
+            try {
+                await client.tui.showToast({
+                    body: {
+                        title: `Worktree: ${name}`,
+                        message: `Created on branch ${branchName}`,
+                        variant: "success",
+                        duration: 4000,
+                    },
+                });
+            }
+            catch {
+                // Toast failure is non-fatal
+            }
+            return `✓ Created worktree successfully
 
 Branch: ${branchName}
 Path: ${absoluteWorktreePath}
@@ -61,18 +92,19 @@ To work in this worktree:
   cd ${absoluteWorktreePath}
 
 Or use worktree_open to get a command to open a new terminal there.`;
-    },
-});
+        },
+    });
+}
 export const list = tool({
     description: "List all git worktrees for this project",
     args: {},
     async execute(args, context) {
         try {
-            const result = await Bun.$ `git worktree list`.cwd(context.worktree).text();
-            if (!result.trim()) {
+            const { stdout } = await git(context.worktree, "worktree", "list");
+            if (!stdout.trim()) {
                 return "No worktrees found.";
             }
-            const lines = result.trim().split("\n");
+            const lines = stdout.trim().split("\n");
             let output = "Git Worktrees:\n\n";
             for (const line of lines) {
                 const parts = line.split(/\s+/);
@@ -92,64 +124,141 @@ export const list = tool({
         }
     },
 });
-export const remove = tool({
-    description: "Remove a git worktree (after merging). Optionally deletes the branch.",
-    args: {
-        name: tool.schema.string().describe("Worktree name to remove"),
-        deleteBranch: tool.schema
-            .boolean()
-            .optional()
-            .describe("Also delete the associated branch (default: false)"),
-    },
-    async execute(args, context) {
-        const { name, deleteBranch = false } = args;
-        const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
-        const absoluteWorktreePath = path.resolve(worktreePath);
-        // Check if worktree exists
-        if (!fs.existsSync(absoluteWorktreePath)) {
-            return `✗ Error: Worktree not found at ${absoluteWorktreePath}
+/**
+ * Factory function that creates the worktree_remove tool with access
+ * to the OpenCode client for toast notifications and PTY cleanup.
+ */
+export function createRemove(client) {
+    return tool({
+        description: "Remove a git worktree (after merging). Optionally deletes the branch.",
+        args: {
+            name: tool.schema.string().describe("Worktree name to remove"),
+            deleteBranch: tool.schema
+                .boolean()
+                .optional()
+                .describe("Also delete the associated branch (default: false)"),
+        },
+        async execute(args, context) {
+            const { name, deleteBranch = false } = args;
+            const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+            const absoluteWorktreePath = path.resolve(worktreePath);
+            // Check if worktree exists
+            if (!fs.existsSync(absoluteWorktreePath)) {
+                return `✗ Error: Worktree not found at ${absoluteWorktreePath}
 
 Use worktree_list to see existing worktrees.`;
-        }
-        // Get branch name before removing
-        let branchName = "";
-        try {
-            branchName = await Bun.$ `git -C ${absoluteWorktreePath} branch --show-current`.text();
-            branchName = branchName.trim();
-        }
-        catch {
-            // Ignore error, branch detection is optional
-        }
-        // Remove the worktree
-        try {
-            await Bun.$ `git worktree remove ${absoluteWorktreePath}`.cwd(context.worktree);
-        }
-        catch (error) {
-            // Try force remove if there are changes
+            }
+            // Get branch name before removing
+            let branchName = "";
             try {
-                await Bun.$ `git worktree remove --force ${absoluteWorktreePath}`.cwd(context.worktree);
+                const { stdout } = await git(absoluteWorktreePath, "branch", "--show-current");
+                branchName = stdout.trim();
+            }
+            catch {
+                // Ignore error, branch detection is optional
             }
-            catch (error2) {
-                return `✗ Error removing worktree: ${error2.message || error2}
+            // ── Close terminal session BEFORE git removes the directory ──
+            let closedSession = false;
+            const session = readSession(absoluteWorktreePath);
+            if (session) {
+                if (session.mode === "pty" && session.ptyId) {
+                    // Close PTY session via OpenCode SDK
+                    try {
+                        await client.pty.remove({ path: { id: session.ptyId } });
+                        closedSession = true;
+                    }
+                    catch {
+                        // PTY may already be closed
+                    }
+                }
+                else if (session.mode === "terminal") {
+                    // Close terminal tab via driver
+                    closedSession = await closeSession(session);
+                }
+                else if (session.mode === "background" && session.pid) {
+                    closedSession = kill(session.pid);
+                }
+                // Fallback: kill PID if driver close failed
+                if (!closedSession && session.pid) {
+                    kill(session.pid);
+                }
+            }
+            // Also clean up legacy .background-pid file
+            const bgPidFile = path.join(absoluteWorktreePath, ".cortex", ".background-pid");
+            if (fs.existsSync(bgPidFile)) {
+                try {
+                    const bgData = JSON.parse(fs.readFileSync(bgPidFile, "utf-8"));
+                    if (bgData.pid)
+                        kill(bgData.pid);
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            // ── Remove the worktree ─────────────────────────────────────
+            try {
+                await git(context.worktree, "worktree", "remove", absoluteWorktreePath);
+            }
+            catch {
+                // Try force remove if there are changes
+                try {
+                    await git(context.worktree, "worktree", "remove", "--force", absoluteWorktreePath);
+                }
+                catch (error2) {
+                    try {
+                        await client.tui.showToast({
+                            body: {
+                                title: `Worktree: ${name}`,
+                                message: `Failed to remove: ${error2.message || error2}`,
+                                variant: "error",
+                                duration: 8000,
+                            },
+                        });
+                    }
+                    catch {
+                        // Toast failure is non-fatal
+                    }
+                    return `✗ Error removing worktree: ${error2.message || error2}
 
 The worktree may have uncommitted changes. Commit or stash them first.`;
+                }
             }
-        }
-        let output = `✓ Removed worktree at ${absoluteWorktreePath}`;
-        // Delete branch if requested
-        if (deleteBranch && branchName) {
+            let output = `✓ Removed worktree at ${absoluteWorktreePath}`;
+            if (closedSession && session) {
+                output += `\n✓ Closed ${session.mode === "pty" ? "PTY session" : `${session.terminal} tab`}`;
+            }
+            // Delete branch if requested
+            if (deleteBranch && branchName) {
+                try {
+                    await git(context.worktree, "branch", "-d", branchName);
+                    output += `\n✓ Deleted branch ${branchName}`;
+                }
+                catch (error) {
+                    output += `\n⚠ Could not delete branch ${branchName}: ${error.message || error}`;
+                    output += "\n  (Branch may not be fully merged. Use git branch -D to force delete.)";
+                }
+            }
+            // Notify via toast
             try {
-                await Bun.$ `git branch -d ${branchName}`.cwd(context.worktree);
-                output += `\n✓ Deleted branch ${branchName}`;
+                const closedInfo = closedSession ? " + closed tab" : "";
+                await client.tui.showToast({
+                    body: {
+                        title: `Worktree: ${name}`,
+                        message: branchName
+                            ? `Removed worktree${closedInfo} (branch ${branchName} ${deleteBranch ? "deleted" : "kept"})`
+                            : `Removed worktree${closedInfo}`,
+                        variant: "success",
+                        duration: 4000,
+                    },
+                });
             }
-            catch (error) {
-                output += `\n⚠ Could not delete branch ${branchName}: ${error.message || error}`;
-                output += "\n  (Branch may not be fully merged. Use git branch -D to force delete.)";
+            catch {
+                // Toast failure is non-fatal
             }
-        }
-        return output;
-    },
-});
+            return output;
+        },
+    });
+}
 export const open = tool({
     description: "Get the command to open a new terminal window in a worktree directory",
     args: {
@@ -197,50 +306,7 @@ ${instructions}
 Worktree path: ${absoluteWorktreePath}`;
     },
 });
-// ─── Terminal Detection ──────────────────────────────────────────────────────
-/**
- * Detect the user's terminal emulator on macOS.
- * Returns "iterm2", "terminal", or "unknown".
- */
-function detectMacTerminal() {
-    // iTerm2 sets ITERM_SESSION_ID and TERM_PROGRAM
-    if (process.env.ITERM_SESSION_ID || process.env.TERM_PROGRAM === "iTerm.app") {
-        return "iterm2";
-    }
-    if (process.env.TERM_PROGRAM === "Apple_Terminal") {
-        return "terminal";
-    }
-    // Check __CFBundleIdentifier for the running app
-    const bundleId = process.env.__CFBundleIdentifier;
-    if (bundleId?.includes("iterm2") || bundleId?.includes("iTerm")) {
-        return "iterm2";
-    }
-    if (bundleId?.includes("Terminal") || bundleId?.includes("apple.Terminal")) {
-        return "terminal";
-    }
-    return "unknown";
-}
-/**
- * Detect the user's terminal emulator on Linux.
- * Returns the terminal name or "unknown".
- */
-function detectLinuxTerminal() {
-    const termProgram = process.env.TERM_PROGRAM;
-    if (termProgram)
-        return termProgram.toLowerCase();
-    // Check common environment hints
-    if (process.env.KITTY_WINDOW_ID)
-        return "kitty";
-    if (process.env.ALACRITTY_SOCKET)
-        return "alacritty";
-    if (process.env.WEZTERM_PANE)
-        return "wezterm";
-    if (process.env.GNOME_TERMINAL_SERVICE)
-        return "gnome-terminal";
-    if (process.env.KONSOLE_VERSION)
-        return "konsole";
-    return "unknown";
-}
+// ─── Terminal detection and tab management now in src/utils/terminal.ts ──────
 /**
  * Find the opencode binary path, checking common locations.
  */
@@ -250,16 +316,10 @@ async function findOpencodeBinary() {
     const wellKnown = path.join(homeDir, ".opencode", "bin", "opencode");
     if (fs.existsSync(wellKnown))
         return wellKnown;
-    // Try which/where
-    try {
-        const result = await Bun.$ `which opencode`.quiet().text();
-        const bin = result.trim();
-        if (bin && fs.existsSync(bin))
-            return bin;
-    }
-    catch {
-        // Not in PATH
-    }
+    // Try which
+    const bin = await which("opencode");
+    if (bin && fs.existsSync(bin))
+        return bin;
     return null;
 }
 /**
@@ -273,99 +333,59 @@ function buildLaunchPrompt(planFilename, customPrompt) {
     }
     return "Check for plans in .cortex/plans/ and begin implementation. If no plan exists, analyze the codebase and suggest next steps.";
 }
-// ─── Mode A: New Terminal Tab ────────────────────────────────────────────────
-async function launchTerminalTab(worktreePath, opencodeBin, agent, prompt) {
-    const platform = process.platform;
-    // Build the command to run inside the new terminal
-    const innerCmd = `cd "${worktreePath}" && "${opencodeBin}" --agent ${agent} --prompt "${prompt.replace(/"/g, '\\"')}"`;
-    if (platform === "darwin") {
-        const terminal = detectMacTerminal();
-        if (terminal === "iterm2") {
-            const script = `tell application "iTerm2"
-  tell current window
-    create tab with default profile
-    tell current session of current tab
-      write text "cd \\"${worktreePath}\\" && \\"${opencodeBin}\\" --agent ${agent}"
-    end tell
-  end tell
-end tell`;
-            try {
-                await Bun.$ `osascript -e ${script}`;
-                return `✓ Opened new iTerm2 tab in worktree`;
-            }
-            catch {
-                // Fall back to generic open
-            }
-        }
-        if (terminal === "terminal" || terminal === "unknown") {
-            // Terminal.app: `do script` opens in a new window by default
-            // Using "do script in window 1" would reuse, so we use a plain `do script`
-            const script = `tell application "Terminal"
-  activate
-  do script "cd \\"${worktreePath}\\" && \\"${opencodeBin}\\" --agent ${agent}"
-end tell`;
-            try {
-                await Bun.$ `osascript -e ${script}`;
-                return `✓ Opened new Terminal.app window in worktree`;
-            }
-            catch (err) {
-                // Last resort: use open -a
-                try {
-                    await Bun.$ `open -a Terminal "${worktreePath}"`;
-                    return `✓ Opened Terminal.app in worktree directory (run opencode manually)`;
-                }
-                catch {
-                    return `✗ Could not open terminal. Manual command:\n  ${innerCmd}`;
-                }
-            }
-        }
-    }
-    if (platform === "linux") {
-        const terminal = detectLinuxTerminal();
-        const launchers = {
-            "kitty": ["kitty", "--directory", worktreePath, "--", "bash", "-c", innerCmd],
-            "alacritty": ["alacritty", "--working-directory", worktreePath, "-e", "bash", "-c", innerCmd],
-            "wezterm": ["wezterm", "start", "--cwd", worktreePath, "--", "bash", "-c", innerCmd],
-            "gnome-terminal": ["gnome-terminal", "--working-directory", worktreePath, "--", "bash", "-c", innerCmd],
-            "konsole": ["konsole", "--workdir", worktreePath, "-e", "bash", "-c", innerCmd],
-        };
-        const args = launchers[terminal];
-        if (args) {
-            try {
-                Bun.spawn(args, { cwd: worktreePath, stdout: "ignore", stderr: "ignore" });
-                return `✓ Opened ${terminal} in worktree`;
-            }
-            catch {
-                // Fall through to generic attempt
-            }
-        }
-        // Generic fallback: try common terminals in order
-        for (const [name, cmdArgs] of Object.entries(launchers)) {
-            try {
-                Bun.spawn(cmdArgs, { cwd: worktreePath, stdout: "ignore", stderr: "ignore" });
-                return `✓ Opened ${name} in worktree`;
-            }
-            catch {
-                continue;
-            }
-        }
-        return `✗ Could not detect terminal emulator. Manual command:\n  ${innerCmd}`;
-    }
-    if (platform === "win32") {
+// ─── Mode A: New Terminal Tab (via driver system) ────────────────────────────
+async function launchTerminalTab(client, worktreePath, branchName, opencodeBin, agent, prompt) {
+    /** Fire a toast notification for terminal launch results. */
+    const notify = async (message, variant = "success") => {
         try {
-            await Bun.$ `start cmd /k "cd /d ${worktreePath} && ${opencodeBin} --agent ${agent}"`;
-            return `✓ Opened new cmd window in worktree`;
+            await client.tui.showToast({
+                body: {
+                    title: `Terminal: ${branchName}`,
+                    message,
+                    variant,
+                    duration: variant === "error" ? 8000 : 4000,
+                },
+            });
         }
         catch {
-            return `✗ Could not open terminal. Manual command:\n  ${innerCmd}`;
+            // Toast failure is non-fatal
         }
+    };
+    const driver = detectDriver();
+    const opts = {
+        worktreePath,
+        opencodeBin,
+        agent,
+        prompt,
+        branchName,
+    };
+    try {
+        const result = await driver.openTab(opts);
+        // Persist session for later cleanup (e.g., worktree_remove)
+        const session = {
+            terminal: driver.name,
+            platform: process.platform,
+            mode: "terminal",
+            branch: branchName,
+            agent,
+            worktreePath,
+            startedAt: new Date().toISOString(),
+            ...result,
+        };
+        writeSession(worktreePath, session);
+        await notify(`Opened ${driver.name} tab with agent '${agent}'`);
+        return `✓ Opened ${driver.name} tab in worktree\n\nBranch: ${branchName}\nTerminal: ${driver.name}`;
+    }
+    catch (error) {
+        await notify(`Could not open terminal: ${error.message || error}`, "error");
+        const innerCmd = `cd "${worktreePath}" && "${opencodeBin}" --agent ${agent}`;
+        return `✗ Could not open terminal (${driver.name}). Manual command:\n  ${innerCmd}`;
     }
-    return `✗ Unsupported platform: ${platform}. Manual command:\n  ${innerCmd}`;
 }
 // ─── Mode B: In-App PTY ─────────────────────────────────────────────────────
 async function launchPty(client, worktreePath, branchName, opencodeBin, agent, prompt) {
     try {
-        await client.pty.create({
+        const response = await client.pty.create({
             body: {
                 command: opencodeBin,
                 args: ["--agent", agent, "--prompt", prompt],
@@ -373,6 +393,35 @@ async function launchPty(client, worktreePath, branchName, opencodeBin, agent, p
                 title: `Worktree: ${branchName}`,
             },
         });
+        // Capture PTY ID and PID from response for later cleanup
+        const ptyId = response.data?.id;
+        const ptyPid = response.data?.pid;
+        // Persist session for cleanup on worktree_remove
+        writeSession(worktreePath, {
+            terminal: "pty",
+            platform: process.platform,
+            mode: "pty",
+            ptyId: ptyId ?? undefined,
+            pid: ptyPid ?? undefined,
+            branch: branchName,
+            agent,
+            worktreePath,
+            startedAt: new Date().toISOString(),
+        });
+        // Show toast for PTY launch
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: `PTY: ${branchName}`,
+                    message: `Created in-app session with agent '${agent}'`,
+                    variant: "success",
+                    duration: 4000,
+                },
+            });
+        }
+        catch {
+            // Toast failure is non-fatal
+        }
         return `✓ Created in-app PTY session for worktree
 
 Branch: ${branchName}
@@ -382,6 +431,19 @@ The PTY is running OpenCode with agent '${agent}' in the worktree.
 Switch to it using OpenCode's terminal panel.`;
     }
     catch (error) {
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: `PTY: ${branchName}`,
+                    message: `Failed to create session: ${error.message || error}`,
+                    variant: "error",
+                    duration: 8000,
+                },
+            });
+        }
+        catch {
+            // Toast failure is non-fatal
+        }
         return `✗ Failed to create PTY session: ${error.message || error}
 
 Falling back to manual command:
@@ -391,18 +453,16 @@ Falling back to manual command:
 // ─── Mode C: Background Session ─────────────────────────────────────────────
 async function launchBackground(client, worktreePath, branchName, opencodeBin, agent, prompt) {
     // Spawn opencode run as a detached background process
-    const proc = Bun.spawn([opencodeBin, "run", "--agent", agent, prompt], {
+    const proc = shellSpawn(opencodeBin, ["run", "--agent", agent, prompt], {
         cwd: worktreePath,
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: "pipe",
         env: {
             ...process.env,
-            // Ensure the background instance knows its directory
             HOME: process.env.HOME || "",
             PATH: process.env.PATH || "",
         },
     });
-    // Save PID for tracking
+    // Save PID for tracking (legacy format)
     const cortexDir = path.join(worktreePath, ".cortex");
     if (!fs.existsSync(cortexDir)) {
         fs.mkdirSync(cortexDir, { recursive: true });
@@ -413,6 +473,17 @@ async function launchBackground(client, worktreePath, branchName, opencodeBin, a
         agent,
         startedAt: new Date().toISOString(),
     }));
+    // Also write unified terminal session for cleanup on worktree_remove
+    writeSession(worktreePath, {
+        terminal: "background",
+        platform: process.platform,
+        mode: "background",
+        pid: proc.pid ?? undefined,
+        branch: branchName,
+        agent,
+        worktreePath,
+        startedAt: new Date().toISOString(),
+    });
     // Show initial toast
     try {
         await client.tui.showToast({
@@ -451,8 +522,11 @@ To check worktree status later:
  */
 async function monitorBackgroundProcess(proc, client, branchName, worktreePath) {
     try {
-        // Wait for the process to exit (non-blocking from the tool's perspective)
-        const exitCode = await proc.exited;
+        // Wait for the process to exit
+        const exitCode = await new Promise((resolve) => {
+            proc.on("exit", (code) => resolve(code ?? 1));
+            proc.on("error", () => resolve(1));
+        });
         // Clean up PID file
         const pidFile = path.join(worktreePath, ".cortex", ".background-pid");
         if (fs.existsSync(pidFile)) {
@@ -554,9 +628,9 @@ Install OpenCode or ensure it's in your PATH.`;
             // ── Detect branch name ─────────────────────────────────────
             let branchName = name;
             try {
-                const branch = await Bun.$ `git -C ${absoluteWorktreePath} branch --show-current`.quiet().text();
-                if (branch.trim())
-                    branchName = branch.trim();
+                const { stdout } = await git(absoluteWorktreePath, "branch", "--show-current");
+                if (stdout.trim())
+                    branchName = stdout.trim();
             }
             catch {
                 // Use worktree name as fallback
@@ -582,7 +656,7 @@ Install OpenCode or ensure it's in your PATH.`;
             let launchResult;
             switch (mode) {
                 case "terminal":
-                    launchResult = await launchTerminalTab(absoluteWorktreePath, opencodeBin, agent, launchPrompt);
+                    launchResult = await launchTerminalTab(client, absoluteWorktreePath, branchName, opencodeBin, agent, launchPrompt);
                     break;
                 case "pty":
                     launchResult = await launchPty(client, absoluteWorktreePath, branchName, opencodeBin, agent, launchPrompt);