dmux 5.3.0 → 5.5.0

package/dist/hooks/useInputHandling.js

@@ -1,21 +1,52 @@
+import { useEffect, useRef } from "react";
+import path from "path";
 import { useInput } from "ink";
 import { StateManager } from "../shared/StateManager.js";
 import { TmuxService } from "../services/TmuxService.js";
 import { STATUS_MESSAGE_DURATION_SHORT, STATUS_MESSAGE_DURATION_LONG, ANIMATION_DELAY, } from "../constants/timing.js";
-import { PaneAction } from "../actions/index.js";
+import { isPaneAction, PaneAction, TOGGLE_PANE_VISIBILITY_ACTION, } from "../actions/index.js";
 import { getMainBranch, getOrphanedWorktrees } from "../utils/git.js";
 import { enforceControlPaneSize } from "../utils/tmux.js";
 import { SIDEBAR_WIDTH } from "../utils/layoutManager.js";
 import { suggestCommand } from "../utils/commands.js";
-import { getPaneProjectRoot } from "../utils/paneProject.js";
+import { getPaneProjectName, getPaneProjectRoot } from "../utils/paneProject.js";
 import { getProjectActionByIndex, } from "../utils/projectActions.js";
 import { createShellPane, getNextDmuxId } from "../utils/shellPaneDetection.js";
+import { getBulkVisibilityAction, getProjectVisibilityAction, partitionPanesByProject, } from "../utils/paneVisibility.js";
+import { buildFilesOnlyCommand } from "../utils/dmuxCommand.js";
 /**
  * Hook that handles all keyboard input for the TUI
  * Extracted from DmuxApp.tsx to reduce component complexity
  */
 export function useInputHandling(params) {
-    const { panes, selectedIndex, setSelectedIndex, isCreatingPane, setIsCreatingPane, runningCommand, isUpdating, isLoading, ignoreInput, isDevMode, quitConfirmMode, setQuitConfirmMode, showCommandPrompt, setShowCommandPrompt, commandInput, setCommandInput, showFileCopyPrompt, setShowFileCopyPrompt, currentCommandType, setCurrentCommandType, projectSettings, saveSettings, settingsManager, popupManager, actionSystem, controlPaneId, setStatusMessage, copyNonGitFiles, runCommandInternal, handlePaneCreationWithAgent, handleReopenWorktree, setDevSourceFromPane, savePanes, loadPanes, cleanExit, availableAgents, panesFile, projectRoot, projectActionItems, findCardInDirection, } = params;
+    const { panes, selectedIndex, setSelectedIndex, isCreatingPane, setIsCreatingPane, runningCommand, isUpdating, isLoading, ignoreInput, isDevMode, quitConfirmMode, setQuitConfirmMode, showCommandPrompt, setShowCommandPrompt, commandInput, setCommandInput, showFileCopyPrompt, setShowFileCopyPrompt, currentCommandType, setCurrentCommandType, projectSettings, saveSettings, settingsManager, popupManager, actionSystem, controlPaneId, setStatusMessage, copyNonGitFiles, runCommandInternal, handlePaneCreationWithAgent, handleCreateChildWorktree, handleReopenWorktree, setDevSourceFromPane, savePanes, loadPanes, cleanExit, availableAgents, panesFile, projectRoot, projectActionItems, findCardInDirection, } = params;
+    const layoutRefreshDebounceRef = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (layoutRefreshDebounceRef.current) {
+                clearTimeout(layoutRefreshDebounceRef.current);
+                layoutRefreshDebounceRef.current = null;
+            }
+        };
+    }, []);
+    const queueLayoutRefresh = () => {
+        if (!controlPaneId) {
+            return;
+        }
+        if (layoutRefreshDebounceRef.current) {
+            clearTimeout(layoutRefreshDebounceRef.current);
+        }
+        layoutRefreshDebounceRef.current = setTimeout(async () => {
+            layoutRefreshDebounceRef.current = null;
+            try {
+                await enforceControlPaneSize(controlPaneId, SIDEBAR_WIDTH, { forceLayout: true });
+            }
+            catch (error) {
+                setStatusMessage(`Setting saved but layout refresh failed: ${error?.message || String(error)}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            }
+        }, 250);
+    };
     const handleCreateAgentPane = async (targetProjectRoot) => {
         const promptValue = await popupManager.launchNewPanePopup(targetProjectRoot);
         if (promptValue) {
@@ -46,13 +77,105 @@ export function useInputHandling(params) {
             setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
         }
     };
+    const openTerminalInWorktree = async (selectedPane) => {
+        if (!selectedPane.worktreePath) {
+            setStatusMessage("Cannot open terminal: this pane has no worktree");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const targetProjectRoot = getPaneProjectRoot(selectedPane, projectRoot);
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(`Opening terminal in ${selectedPane.slug}...`);
+            const tmuxService = TmuxService.getInstance();
+            const newPaneId = await tmuxService.splitPane({ cwd: selectedPane.worktreePath });
+            // Wait for pane creation to settle
+            await new Promise((resolve) => setTimeout(resolve, ANIMATION_DELAY));
+            const shellPane = await createShellPane(newPaneId, getNextDmuxId(panes));
+            shellPane.projectRoot = targetProjectRoot;
+            await savePanes([...panes, shellPane]);
+            setStatusMessage(`Opened terminal in ${selectedPane.slug}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            // Force a reload to ensure tmux metadata and pane IDs are in sync
+            await loadPanes();
+        }
+        catch (error) {
+            setStatusMessage(`Failed to open terminal in worktree: ${error.message}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
+    const openFileBrowserInWorktree = async (selectedPane) => {
+        if (!selectedPane.worktreePath) {
+            setStatusMessage("Cannot open file browser: this pane has no worktree");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const existingBrowserPane = panes.find((pane) => pane.browserPath === selectedPane.worktreePath && !pane.hidden);
+        if (existingBrowserPane) {
+            try {
+                await TmuxService.getInstance().selectPane(existingBrowserPane.paneId);
+                setStatusMessage(`File browser already open for ${selectedPane.slug}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            }
+            catch (error) {
+                setStatusMessage(`Failed to focus file browser: ${error?.message || String(error)}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            }
+            return;
+        }
+        const targetProjectRoot = getPaneProjectRoot(selectedPane, projectRoot);
+        const targetProjectName = path.basename(targetProjectRoot);
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(`Opening file browser for ${selectedPane.slug}...`);
+            const tmuxService = TmuxService.getInstance();
+            const newPaneId = await tmuxService.splitPane({
+                cwd: selectedPane.worktreePath,
+                command: buildFilesOnlyCommand(),
+            });
+            await new Promise((resolve) => setTimeout(resolve, ANIMATION_DELAY));
+            const slugBase = `files-${path.basename(selectedPane.worktreePath)}`;
+            let slug = slugBase;
+            let suffix = 2;
+            while (panes.some((pane) => pane.slug === slug)) {
+                slug = `${slugBase}-${suffix}`;
+                suffix += 1;
+            }
+            const browserPane = {
+                id: `dmux-${getNextDmuxId(panes)}`,
+                slug,
+                prompt: "",
+                paneId: newPaneId,
+                projectRoot: targetProjectRoot,
+                projectName: targetProjectName,
+                type: "shell",
+                shellType: "fb",
+                browserPath: selectedPane.worktreePath,
+            };
+            await tmuxService.setPaneTitle(newPaneId, slug);
+            await savePanes([...panes, browserPane]);
+            await loadPanes();
+            setStatusMessage(`Opened file browser for ${selectedPane.slug}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+        }
+        catch (error) {
+            setStatusMessage(`Failed to open file browser: ${error?.message || String(error)}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
     const handleCreatePaneInProject = async () => {
         const selectedAction = getProjectActionByIndex(projectActionItems, selectedIndex);
         const selectedPane = selectedIndex < panes.length ? panes[selectedIndex] : undefined;
         const defaultProjectPath = selectedPane
             ? getPaneProjectRoot(selectedPane, projectRoot)
             : (selectedAction?.projectRoot || projectRoot);
-        const requestedProjectPath = await popupManager.launchProjectSelectPopup(defaultProjectPath);
+        const requestedProjectPath = await popupManager.launchProjectSelectPopup(defaultProjectPath, defaultProjectPath);
         if (!requestedProjectPath) {
             return;
         }
@@ -85,19 +208,309 @@ export function useInputHandling(params) {
         const prompt = "I would like to create or edit my dmux hooks in .dmux-hooks. Please read AGENTS.md or CLAUDE.md first, then ask me what I want to create or modify.";
         await handlePaneCreationWithAgent(prompt, hooksProjectRoot);
     };
+    const refreshPaneLayout = async () => {
+        if (!controlPaneId) {
+            return;
+        }
+        await enforceControlPaneSize(controlPaneId, SIDEBAR_WIDTH, {
+            forceLayout: true,
+            suppressLayoutLogs: true,
+        });
+    };
+    const getPaneShowTarget = async (excludedPaneId) => {
+        const visiblePaneId = panes.find((pane) => !pane.hidden && pane.paneId !== excludedPaneId)?.paneId;
+        if (visiblePaneId) {
+            return visiblePaneId;
+        }
+        if (controlPaneId) {
+            return controlPaneId;
+        }
+        try {
+            return await TmuxService.getInstance().getCurrentPaneId();
+        }
+        catch {
+            return null;
+        }
+    };
+    const togglePaneVisibility = async (selectedPane) => {
+        const tmuxService = TmuxService.getInstance();
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(selectedPane.hidden ? `Showing ${selectedPane.slug}...` : `Hiding ${selectedPane.slug}...`);
+            if (selectedPane.hidden) {
+                const targetPaneId = await getPaneShowTarget(selectedPane.paneId);
+                if (!targetPaneId) {
+                    throw new Error("No target pane is available to show this pane");
+                }
+                await tmuxService.joinPaneToTarget(selectedPane.paneId, targetPaneId);
+            }
+            else {
+                await tmuxService.breakPaneToWindow(selectedPane.paneId, `dmux-hidden-${selectedPane.id}`);
+            }
+            await savePanes(panes.map((pane) => pane.id === selectedPane.id
+                ? { ...pane, hidden: !selectedPane.hidden }
+                : pane));
+            await refreshPaneLayout();
+            await loadPanes();
+            setStatusMessage(selectedPane.hidden
+                ? `Showing ${selectedPane.slug}`
+                : `Hid ${selectedPane.slug}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+        }
+        catch (error) {
+            setStatusMessage(`Failed to toggle pane visibility: ${error?.message || String(error)}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
+    const toggleOtherPanesVisibility = async (selectedPane) => {
+        const action = getBulkVisibilityAction(panes, selectedPane);
+        if (!action) {
+            setStatusMessage("No other panes to toggle");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const targetPanes = panes.filter((pane) => pane.id !== selectedPane.id
+            && (action === "hide-others" ? !pane.hidden : pane.hidden));
+        if (targetPanes.length === 0) {
+            setStatusMessage("No other panes to toggle");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const tmuxService = TmuxService.getInstance();
+        const hidden = action === "hide-others";
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(hidden ? "Hiding other panes..." : "Showing other panes...");
+            for (const pane of targetPanes) {
+                if (hidden) {
+                    await tmuxService.breakPaneToWindow(pane.paneId, `dmux-hidden-${pane.id}`);
+                    continue;
+                }
+                const targetPaneId = await getPaneShowTarget(pane.paneId);
+                if (!targetPaneId) {
+                    throw new Error("No target pane is available to show hidden panes");
+                }
+                await tmuxService.joinPaneToTarget(pane.paneId, targetPaneId);
+            }
+            const targetPaneIds = new Set(targetPanes.map((pane) => pane.id));
+            await savePanes(panes.map((pane) => targetPaneIds.has(pane.id) ? { ...pane, hidden } : pane));
+            await refreshPaneLayout();
+            await loadPanes();
+            setStatusMessage(hidden
+                ? `Hid ${targetPanes.length} other pane${targetPanes.length === 1 ? "" : "s"}`
+                : `Showed ${targetPanes.length} other pane${targetPanes.length === 1 ? "" : "s"}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+        }
+        catch (error) {
+            setStatusMessage(`Failed to toggle other panes: ${error?.message || String(error)}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
+    const toggleProjectPanesVisibility = async (targetProjectRoot = getActiveProjectRoot()) => {
+        const action = getProjectVisibilityAction(panes, targetProjectRoot, projectRoot);
+        if (!action) {
+            setStatusMessage("No project panes to toggle");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const { projectPanes, otherPanes } = partitionPanesByProject(panes, targetProjectRoot, projectRoot);
+        if (projectPanes.length === 0) {
+            setStatusMessage("No project panes to toggle");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const projectName = getPaneProjectName(projectPanes[0], projectRoot);
+        const panesToShow = action === "focus-project"
+            ? projectPanes.filter((pane) => pane.hidden)
+            : panes.filter((pane) => pane.hidden);
+        const panesToHide = action === "focus-project"
+            ? otherPanes.filter((pane) => !pane.hidden)
+            : [];
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(action === "focus-project"
+                ? `Showing ${projectName} panes...`
+                : "Showing all panes...");
+            // Show target project panes before hiding others so we always have
+            // an attached pane available for tmux join targets.
+            for (const pane of panesToShow) {
+                const targetPaneId = await getPaneShowTarget(pane.paneId);
+                if (!targetPaneId) {
+                    throw new Error("No target pane is available to show hidden panes");
+                }
+                await TmuxService.getInstance().joinPaneToTarget(pane.paneId, targetPaneId);
+            }
+            for (const pane of panesToHide) {
+                await TmuxService.getInstance().breakPaneToWindow(pane.paneId, `dmux-hidden-${pane.id}`);
+            }
+            const shownPaneIds = new Set(panesToShow.map((pane) => pane.id));
+            const hiddenPaneIds = new Set(panesToHide.map((pane) => pane.id));
+            await savePanes(panes.map((pane) => {
+                if (shownPaneIds.has(pane.id)) {
+                    return { ...pane, hidden: false };
+                }
+                if (hiddenPaneIds.has(pane.id)) {
+                    return { ...pane, hidden: true };
+                }
+                return pane;
+            }));
+            await refreshPaneLayout();
+            await loadPanes();
+            setStatusMessage(action === "focus-project"
+                ? panesToHide.length > 0
+                    ? `Showing only ${projectName} panes`
+                    : `Showed ${projectName} panes`
+                : "Showed all panes");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+        }
+        catch (error) {
+            setStatusMessage(`Failed to toggle project panes: ${error?.message || String(error)}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
     const openPaneMenu = async (pane) => {
-        const actionId = await popupManager.launchKebabMenuPopup(pane);
+        const actionId = await popupManager.launchKebabMenuPopup(pane, panes);
         if (!actionId) {
             return;
         }
+        if (actionId === TOGGLE_PANE_VISIBILITY_ACTION) {
+            await togglePaneVisibility(pane);
+            return;
+        }
+        if (actionId === "hide-others" || actionId === "show-others") {
+            await toggleOtherPanesVisibility(pane);
+            return;
+        }
+        if (actionId === "focus-project" || actionId === "show-all") {
+            await toggleProjectPanesVisibility(getPaneProjectRoot(pane, projectRoot));
+            return;
+        }
         if (actionId === PaneAction.SET_SOURCE) {
             await setDevSourceFromPane(pane);
             return;
         }
+        if (actionId === PaneAction.ATTACH_AGENT) {
+            await attachAgentsToPane(pane);
+            return;
+        }
+        if (actionId === PaneAction.CREATE_CHILD_WORKTREE) {
+            await handleCreateChildWorktree(pane);
+            return;
+        }
+        if (actionId === PaneAction.OPEN_TERMINAL_IN_WORKTREE) {
+            await openTerminalInWorktree(pane);
+            return;
+        }
+        if (actionId === PaneAction.OPEN_FILE_BROWSER) {
+            await openFileBrowserInWorktree(pane);
+            return;
+        }
+        if (!isPaneAction(actionId)) {
+            setStatusMessage(`Unknown menu action: ${actionId}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            return;
+        }
         await actionSystem.executeAction(actionId, pane, {
             mainBranch: getMainBranch(),
         });
     };
+    const attachAgentsToPane = async (selectedPane) => {
+        if (!selectedPane.worktreePath) {
+            setStatusMessage("Cannot attach agent: this pane has no worktree");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        const targetProjectRoot = getPaneProjectRoot(selectedPane, projectRoot);
+        // Warn if agent is actively working
+        if (selectedPane.agentStatus === "working") {
+            const confirmed = await popupManager.launchConfirmPopup("Agent Active", `Agent in "${selectedPane.slug}" is currently working. Attach another agent anyway?`, "Attach", "Cancel", targetProjectRoot);
+            if (!confirmed)
+                return;
+        }
+        let selectedAgents = [];
+        if (availableAgents.length === 0) {
+            setStatusMessage("No agents available");
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            return;
+        }
+        else if (availableAgents.length === 1) {
+            selectedAgents = [availableAgents[0]];
+        }
+        else {
+            const agents = await popupManager.launchAgentChoicePopup(targetProjectRoot);
+            if (agents === null) {
+                return;
+            }
+            if (agents.length === 0) {
+                setStatusMessage("Select at least one agent");
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+                return;
+            }
+            selectedAgents = agents;
+        }
+        // Prompt input
+        const promptValue = await popupManager.launchNewPanePopup(targetProjectRoot);
+        if (!promptValue)
+            return;
+        try {
+            setIsCreatingPane(true);
+            setStatusMessage(selectedAgents.length > 1
+                ? `Attaching ${selectedAgents.length} agents...`
+                : "Attaching agent...");
+            const { attachAgentToWorktree } = await import("../utils/attachAgent.js");
+            const createdPanes = [];
+            const failedAgents = [];
+            for (const agent of selectedAgents) {
+                try {
+                    const result = await attachAgentToWorktree({
+                        targetPane: selectedPane,
+                        prompt: promptValue,
+                        agent,
+                        existingPanes: [...panes, ...createdPanes],
+                        sessionProjectRoot: projectRoot,
+                        sessionConfigPath: panesFile,
+                    });
+                    createdPanes.push(result.pane);
+                }
+                catch {
+                    failedAgents.push(agent);
+                }
+            }
+            if (createdPanes.length > 0) {
+                const updatedPanes = [...panes, ...createdPanes];
+                await savePanes(updatedPanes);
+                await loadPanes();
+            }
+            if (failedAgents.length === 0) {
+                setStatusMessage(`Attached ${createdPanes.length} agent${createdPanes.length === 1 ? "" : "s"} to ${selectedPane.slug}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            }
+            else if (createdPanes.length === 0) {
+                setStatusMessage(`Failed to attach agents: ${failedAgents.join(", ")}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            }
+            else {
+                setStatusMessage(`Attached ${createdPanes.length}/${selectedAgents.length} agents to ${selectedPane.slug} (${failedAgents.length} failed)`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            }
+        }
+        catch (error) {
+            setStatusMessage(`Failed to attach agent: ${error.message}`);
+            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+        }
+        finally {
+            setIsCreatingPane(false);
+        }
+    };
     useInput(async (input, key) => {
         // Ignore input temporarily after popup operations (prevents buffered keys from being processed)
         if (ignoreInput) {
@@ -232,67 +645,19 @@ export function useInputHandling(params) {
             return;
         }
         if (input === "a" && selectedIndex < panes.length) {
-            // Attach agent to selected pane's worktree
-            const selectedPane = panes[selectedIndex];
-            if (!selectedPane.worktreePath) {
-                setStatusMessage("Cannot attach agent: this pane has no worktree");
-                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
-                return;
-            }
-            // Warn if agent is actively working
-            if (selectedPane.agentStatus === "working") {
-                const confirmed = await popupManager.launchConfirmPopup("Agent Active", `Agent in "${selectedPane.slug}" is currently working. Attach another agent anyway?`, "Attach", "Cancel");
-                if (!confirmed)
-                    return;
-            }
-            // Agent choice (single agent only, no A/B pairs)
-            let chosenAgent = null;
-            if (availableAgents.length === 0) {
-                setStatusMessage("No agents available");
-                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
-                return;
-            }
-            else if (availableAgents.length === 1) {
-                chosenAgent = availableAgents[0];
-            }
-            else {
-                const agents = await popupManager.launchAgentChoicePopup();
-                if (agents && agents.length > 0) {
-                    chosenAgent = agents[0]; // Single agent for attach (no A/B)
-                }
-            }
-            if (!chosenAgent)
-                return;
-            // Prompt input
-            const promptValue = await popupManager.launchNewPanePopup(getPaneProjectRoot(selectedPane, projectRoot));
-            if (!promptValue)
-                return;
-            // Attach agent to worktree
-            try {
-                setIsCreatingPane(true);
-                setStatusMessage("Attaching agent...");
-                const { attachAgentToWorktree } = await import("../utils/attachAgent.js");
-                const result = await attachAgentToWorktree({
-                    targetPane: selectedPane,
-                    prompt: promptValue,
-                    agent: chosenAgent,
-                    existingPanes: panes,
-                    sessionProjectRoot: projectRoot,
-                    sessionConfigPath: panesFile,
-                });
-                const updatedPanes = [...panes, result.pane];
-                await savePanes(updatedPanes);
-                await loadPanes();
-                setStatusMessage(`Attached ${chosenAgent} to ${selectedPane.slug}`);
-                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
-            }
-            catch (error) {
-                setStatusMessage(`Failed to attach agent: ${error.message}`);
-                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
-            }
-            finally {
-                setIsCreatingPane(false);
-            }
+            await attachAgentsToPane(panes[selectedIndex]);
+            return;
+        }
+        else if (input === "b" && selectedIndex < panes.length) {
+            await handleCreateChildWorktree(panes[selectedIndex]);
+            return;
+        }
+        else if (input === "f" && selectedIndex < panes.length) {
+            await openFileBrowserInWorktree(panes[selectedIndex]);
+            return;
+        }
+        else if (input === "A" && selectedIndex < panes.length) {
+            await openTerminalInWorktree(panes[selectedIndex]);
             return;
         }
         else if (input === "m" && selectedIndex < panes.length) {
@@ -306,34 +671,89 @@ export function useInputHandling(params) {
                 // Launch hooks popup
                 await popupManager.launchHooksPopup(async () => {
                     await launchHooksAuthoringSession();
-                });
-            });
+                }, getActiveProjectRoot());
+            }, getActiveProjectRoot());
             if (result) {
-                settingsManager.updateSetting(result.key, result.value, result.scope);
-                setStatusMessage(`Setting saved (${result.scope})`);
-                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+                try {
+                    const updates = Array.isArray(result.updates)
+                        ? result.updates
+                        : [result];
+                    let savedCount = 0;
+                    let layoutBoundsUpdated = false;
+                    let lastScope = null;
+                    for (const update of updates) {
+                        if (!update
+                            || typeof update.key !== "string"
+                            || (update.scope !== "global" && update.scope !== "project")) {
+                            continue;
+                        }
+                        settingsManager.updateSetting(update.key, update.value, update.scope);
+                        savedCount += 1;
+                        lastScope = update.scope;
+                        if (update.key === "minPaneWidth" || update.key === "maxPaneWidth") {
+                            layoutBoundsUpdated = true;
+                        }
+                    }
+                    if (layoutBoundsUpdated) {
+                        queueLayoutRefresh();
+                    }
+                    if (savedCount > 0) {
+                        const statusMessage = savedCount === 1
+                            ? `Setting saved (${lastScope})`
+                            : `${savedCount} settings saved`;
+                        setStatusMessage(statusMessage);
+                        setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+                    }
+                }
+                catch (error) {
+                    setStatusMessage(`Failed to save setting: ${error?.message || String(error)}`);
+                    setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+                }
             }
         }
         else if (input === "l") {
             // Open logs popup
-            await popupManager.launchLogsPopup();
+            await popupManager.launchLogsPopup(getActiveProjectRoot());
         }
         else if (input === "h") {
-            // Launch hooks authoring session directly
-            await launchHooksAuthoringSession();
+            if (selectedIndex < panes.length) {
+                await togglePaneVisibility(panes[selectedIndex]);
+            }
+            else {
+                setStatusMessage("Select a pane to toggle visibility");
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            }
+        }
+        else if (input === "H") {
+            if (selectedIndex < panes.length) {
+                await toggleOtherPanesVisibility(panes[selectedIndex]);
+            }
+            else {
+                setStatusMessage("Select a pane to toggle the others");
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            }
+        }
+        else if (input === "P") {
+            await toggleProjectPanesVisibility();
         }
         else if (input === "?") {
             // Open keyboard shortcuts popup
-            const shortcutsAction = await popupManager.launchShortcutsPopup(!!controlPaneId);
+            const shortcutsAction = await popupManager.launchShortcutsPopup(!!controlPaneId, getActiveProjectRoot());
             if (shortcutsAction === "hooks") {
                 await launchHooksAuthoringSession();
             }
         }
         else if (input === "L" && controlPaneId) {
             // Reset layout to sidebar configuration (Shift+L)
-            enforceControlPaneSize(controlPaneId, SIDEBAR_WIDTH);
-            setStatusMessage("Layout reset");
-            setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            try {
+                await enforceControlPaneSize(controlPaneId, SIDEBAR_WIDTH, { forceLayout: true });
+                setStatusMessage("Layout reset");
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
+            }
+            catch (error) {
+                setStatusMessage(`Failed to reset layout: ${error?.message || String(error)}`);
+                setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_LONG);
+            }
         }
         else if (input === "T") {
             // Demo toasts (Shift+T) - cycles through different types
@@ -369,7 +789,7 @@ export function useInputHandling(params) {
                 setTimeout(() => setStatusMessage(""), STATUS_MESSAGE_DURATION_SHORT);
                 return;
             }
-            const result = await popupManager.launchReopenWorktreePopup(orphanedWorktrees);
+            const result = await popupManager.launchReopenWorktreePopup(orphanedWorktrees, targetProjectRoot);
             if (result) {
                 await handleReopenWorktree(result.slug, result.path, targetProjectRoot);
             }