@akiojin/gwt 4.10.0 → 4.12.0

package/dist/cli/ui/App.solid.js

@@ -0,0 +1,1395 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@opentui/solid/jsx-runtime";
+/** @jsxImportSource @opentui/solid */
+import { useKeyboard, useRenderer } from "@opentui/solid";
+import { batch, createEffect, createMemo, createSignal, onCleanup, onMount, } from "solid-js";
+import { BranchListScreen } from "./screens/solid/BranchListScreen.js";
+import { HelpOverlay } from "./components/solid/HelpOverlay.js";
+import { WizardController, } from "./components/solid/WizardController.js";
+import { SelectorScreen, } from "./screens/solid/SelectorScreen.js";
+import { LogScreen } from "./screens/solid/LogScreen.js";
+import { LogDetailScreen } from "./screens/solid/LogDetailScreen.js";
+import { ErrorScreen } from "./screens/solid/ErrorScreen.js";
+import { LoadingIndicatorScreen } from "./screens/solid/LoadingIndicator.js";
+import { WorktreeCreateScreen } from "./screens/solid/WorktreeCreateScreen.js";
+import { InputScreen } from "./screens/solid/InputScreen.js";
+import { ConfirmScreen } from "./screens/solid/ConfirmScreen.js";
+import { useTerminalSize } from "./hooks/solid/useTerminalSize.js";
+import { EnvironmentScreen } from "./screens/solid/EnvironmentScreen.js";
+import { ProfileScreen } from "./screens/solid/ProfileScreen.js";
+import { ProfileEnvScreen } from "./screens/solid/ProfileEnvScreen.js";
+import { calculateStatistics } from "./utils/statisticsCalculator.js";
+import { formatBranchItems } from "./utils/branchFormatter.js";
+import { createLogger } from "../../logging/logger.js";
+const logger = createLogger({ category: "app" });
+import { getDefaultInferenceForModel, getDefaultModelOption, normalizeModelId, } from "./utils/modelOptions.js";
+import { resolveBaseBranchLabel, resolveBaseBranchRef, } from "./utils/baseBranch.js";
+import { getAllBranches, getCurrentBranch, getLocalBranches, getRepositoryRoot, deleteBranch, } from "../../git.js";
+import { isProtectedBranchName, getCleanupStatus, listAdditionalWorktrees, removeWorktree, repairWorktrees, } from "../../worktree.js";
+import { getConfig, getLastToolUsageMap, loadSession, } from "../../config/index.js";
+import { findLatestBranchSessionsByTool, refreshQuickStartEntries, } from "./utils/continueSession.js";
+import { getAllCodingAgents } from "../../config/tools.js";
+import { clearLogFiles, getTodayLogDate, readLogLinesForDate, resolveLogTarget, } from "../../logging/reader.js";
+import { parseLogLines } from "../../logging/formatter.js";
+import { copyToClipboard } from "./utils/clipboard.js";
+import { getPackageVersion } from "../../utils.js";
+import { createProfile, deleteProfile, loadProfiles, setActiveProfile, updateProfile, } from "../../config/profiles.js";
+import { isValidProfileName, } from "../../types/profiles.js";
+import { BRANCH_PREFIXES } from "../../config/constants.js";
+import { prefetchAgentVersions } from "./utils/versionCache.js";
+import { getBunxAgentIds } from "./utils/versionFetcher.js";
+const UNSAFE_SELECTION_MESSAGE = "Unsafe branch selected. Select anyway?";
+const DEFAULT_SCREEN = "branch-list";
+const buildStats = (branches) => calculateStatistics(branches);
+const applyCleanupStatus = (items, statusByBranch) => items.map((branch) => {
+    const status = statusByBranch.get(branch.name);
+    if (!status) {
+        return { ...branch, safeToCleanup: false, isUnmerged: false };
+    }
+    const safeToCleanup = status.hasUpstream && status.reasons.includes("no-diff-with-base");
+    const isUnmerged = status.hasUpstream && status.hasUniqueCommits;
+    const worktree = branch.worktree
+        ? {
+            ...branch.worktree,
+            ...(status.hasUncommittedChanges !== undefined
+                ? { hasUncommittedChanges: status.hasUncommittedChanges }
+                : {}),
+        }
+        : undefined;
+    const base = {
+        ...branch,
+        safeToCleanup,
+        isUnmerged,
+        hasUnpushedCommits: status.hasUnpushedCommits,
+    };
+    return worktree ? { ...base, worktree } : base;
+});
+const buildCleanupSafetyPending = (items) => {
+    const pending = new Set();
+    for (const branch of items) {
+        if (branch.type === "remote") {
+            continue;
+        }
+        if (branch.worktree) {
+            pending.add(branch.name);
+            continue;
+        }
+        if (isProtectedBranchName(branch.name)) {
+            continue;
+        }
+        pending.add(branch.name);
+    }
+    return pending;
+};
+const toLocalBranchName = (name) => {
+    const segments = name.split("/");
+    if (segments.length <= 1) {
+        return name;
+    }
+    return segments.slice(1).join("/");
+};
+const toSelectedBranchState = (branch) => {
+    const isRemote = branch.type === "remote";
+    const baseName = isRemote ? toLocalBranchName(branch.name) : branch.name;
+    return {
+        name: baseName,
+        displayName: branch.name,
+        branchType: branch.type,
+        branchCategory: branch.branchType,
+        worktreePath: branch.worktree?.path ?? null,
+        ...(isRemote ? { remoteBranch: branch.name } : {}),
+    };
+};
+export function AppSolid(props) {
+    const renderer = useRenderer();
+    const terminal = useTerminalSize();
+    let hasExited = false;
+    const exitApp = (result) => {
+        if (hasExited)
+            return;
+        hasExited = true;
+        props.onExit?.(result);
+        renderer.destroy();
+    };
+    const [currentScreen, setCurrentScreen] = createSignal(props.initialScreen ?? DEFAULT_SCREEN);
+    const [screenStack, setScreenStack] = createSignal([]);
+    const [helpVisible, setHelpVisible] = createSignal(false);
+    const [wizardVisible, setWizardVisible] = createSignal(false);
+    const [branchItems, setBranchItems] = createSignal(props.branches ?? []);
+    const [stats, setStats] = createSignal(props.stats ?? buildStats(props.branches ?? []));
+    const [loading, setLoading] = createSignal(!props.branches);
+    const [error, setError] = createSignal(null);
+    // ブランチ一覧のカーソル位置（グローバル管理で再マウント時もリセットされない）
+    const [branchCursorPosition, setBranchCursorPosition] = createSignal(0);
+    const [toolItems, setToolItems] = createSignal([]);
+    const [toolError, setToolError] = createSignal(null);
+    const [version, setVersion] = createSignal(props.version ?? null);
+    const workingDirectory = createMemo(() => props.workingDirectory ?? process.cwd());
+    const [selectedBranch, setSelectedBranch] = createSignal(null);
+    const [selectedTool, setSelectedTool] = createSignal(null);
+    const [selectedMode, setSelectedMode] = createSignal("normal");
+    const [selectedBranches, setSelectedBranches] = createSignal([]);
+    const [unsafeSelectionConfirmVisible, setUnsafeSelectionConfirmVisible] = createSignal(false);
+    const [unsafeConfirmInputLocked, setUnsafeConfirmInputLocked] = createSignal(false);
+    const [unsafeSelectionTarget, setUnsafeSelectionTarget] = createSignal(null);
+    const [branchFooterMessage, setBranchFooterMessage] = createSignal(null);
+    const [branchInputLocked, setBranchInputLocked] = createSignal(false);
+    const [cleanupIndicators, setCleanupIndicators] = createSignal({});
+    const [cleanupStatusByBranch, setCleanupStatusByBranch] = createSignal(new Map());
+    const [cleanupSafetyLoading, setCleanupSafetyLoading] = createSignal(false);
+    const [cleanupSafetyPending, setCleanupSafetyPending] = createSignal(new Set());
+    const [isNewBranch, setIsNewBranch] = createSignal(false);
+    const [newBranchBaseRef, setNewBranchBaseRef] = createSignal(null);
+    const [creationSource, setCreationSource] = createSignal(null);
+    const [createBranchName, setCreateBranchName] = createSignal("", {
+        equals: false,
+    });
+    const [suppressCreateKey, setSuppressCreateKey] = createSignal(null);
+    const [defaultBaseBranch, setDefaultBaseBranch] = createSignal("main");
+    const suppressBranchInputOnce = () => {
+        setUnsafeConfirmInputLocked(true);
+        queueMicrotask(() => {
+            setUnsafeConfirmInputLocked(false);
+        });
+    };
+    const unsafeConfirmBoxWidth = createMemo(() => {
+        const columns = terminal().columns || 80;
+        return Math.max(1, Math.floor(columns * 0.6));
+    });
+    const unsafeConfirmContentWidth = createMemo(() => Math.max(0, unsafeConfirmBoxWidth() - 4));
+    // セッション履歴（最終使用エージェントなど）
+    const [sessionHistory, setSessionHistory] = createSignal([]);
+    const [quickStartHistory, setQuickStartHistory] = createSignal([]);
+    // 選択中ブランチの履歴をフィルタリング
+    const historyForBranch = createMemo(() => {
+        const history = sessionHistory();
+        const branch = selectedBranch();
+        if (!branch)
+            return [];
+        return findLatestBranchSessionsByTool(history, branch.name, branch.worktreePath ?? null);
+    });
+    createEffect(() => {
+        setQuickStartHistory(historyForBranch());
+    });
+    createEffect(() => {
+        const branch = selectedBranch();
+        const baseHistory = historyForBranch();
+        if (!wizardVisible() || !branch || baseHistory.length === 0) {
+            return;
+        }
+        const worktreePath = branch.worktreePath ?? null;
+        if (!worktreePath) {
+            return;
+        }
+        const branchName = branch.name;
+        void (async () => {
+            const refreshed = await refreshQuickStartEntries(baseHistory, {
+                branch: branchName,
+                worktreePath,
+            });
+            if (selectedBranch()?.name !== branchName) {
+                return;
+            }
+            setQuickStartHistory(refreshed);
+        })();
+    });
+    const [logEntries, setLogEntries] = createSignal([]);
+    const [logLoading, setLogLoading] = createSignal(false);
+    const [logError, setLogError] = createSignal(null);
+    const [logSelectedEntry, setLogSelectedEntry] = createSignal(null);
+    const [logSelectedDate, setLogSelectedDate] = createSignal(getTodayLogDate());
+    const [logNotification, setLogNotification] = createSignal(null);
+    const [logTailEnabled, setLogTailEnabled] = createSignal(false);
+    const [logTargetBranch, setLogTargetBranch] = createSignal(null);
+    const [profileItems, setProfileItems] = createSignal([]);
+    const [activeProfile, setActiveProfileName] = createSignal(null);
+    const [profileError, setProfileError] = createSignal(null);
+    const [profilesConfig, setProfilesConfig] = createSignal(null);
+    const [profileActionError, setProfileActionError] = createSignal(null);
+    const [profileActionHint, setProfileActionHint] = createSignal(null);
+    const [selectedProfileName, setSelectedProfileName] = createSignal(null);
+    const [profileInputValue, setProfileInputValue] = createSignal("", {
+        equals: false,
+    });
+    const [profileInputMode, setProfileInputMode] = createSignal("create-profile");
+    const [profileInputSuppressKey, setProfileInputSuppressKey] = createSignal(null);
+    const [profileEnvKey, setProfileEnvKey] = createSignal(null);
+    const [profileConfirmMode, setProfileConfirmMode] = createSignal("delete-profile");
+    const logTarget = createMemo(() => resolveLogTarget(logTargetBranch(), workingDirectory()));
+    const logBranchLabel = createMemo(() => logTargetBranch()?.label ?? null);
+    const logSourceLabel = createMemo(() => {
+        const target = logTarget();
+        if (!target.sourcePath) {
+            return "(none)";
+        }
+        if (target.reason === "current-working-directory" ||
+            target.reason === "working-directory") {
+            return `${target.sourcePath} (cwd)`;
+        }
+        if (target.reason === "worktree-inaccessible") {
+            return `${target.sourcePath} (inaccessible)`;
+        }
+        return target.sourcePath;
+    });
+    const selectedProfileConfig = createMemo(() => {
+        const name = selectedProfileName();
+        const config = profilesConfig();
+        if (!name || !config?.profiles?.[name]) {
+            return null;
+        }
+        return { name, profile: config.profiles[name] };
+    });
+    const profileEnvVariables = createMemo(() => {
+        const entry = selectedProfileConfig();
+        if (!entry) {
+            return [];
+        }
+        return Object.entries(entry.profile.env ?? {})
+            .map(([key, value]) => ({ key, value }))
+            .sort((a, b) => a.key.localeCompare(b.key));
+    });
+    const osEnvVariables = createMemo(() => Object.entries(process.env)
+        .filter(([, value]) => typeof value === "string")
+        .map(([key, value]) => ({ key, value: String(value) }))
+        .sort((a, b) => a.key.localeCompare(b.key)));
+    let cleanupSafetyRequestId = 0;
+    const refreshCleanupSafety = async () => {
+        const requestId = ++cleanupSafetyRequestId;
+        const pendingBranches = buildCleanupSafetyPending(branchItems());
+        setCleanupSafetyPending(pendingBranches);
+        setCleanupSafetyLoading(pendingBranches.size > 0);
+        const statusByBranch = new Map();
+        const applyProgress = (status) => {
+            if (requestId !== cleanupSafetyRequestId) {
+                return;
+            }
+            statusByBranch.set(status.branch, status);
+            batch(() => {
+                setCleanupStatusByBranch(new Map(statusByBranch));
+                setBranchItems((items) => applyCleanupStatus(items, statusByBranch));
+                setCleanupSafetyPending((prev) => {
+                    if (!prev.has(status.branch)) {
+                        return prev;
+                    }
+                    const next = new Set(prev);
+                    next.delete(status.branch);
+                    return next;
+                });
+            });
+        };
+        try {
+            const cleanupStatuses = await getCleanupStatus({
+                onProgress: applyProgress,
+            });
+            if (requestId !== cleanupSafetyRequestId) {
+                return;
+            }
+            if (cleanupStatuses.length > statusByBranch.size) {
+                cleanupStatuses.forEach((status) => {
+                    if (!statusByBranch.has(status.branch)) {
+                        applyProgress(status);
+                    }
+                });
+            }
+        }
+        catch (err) {
+            if (requestId !== cleanupSafetyRequestId) {
+                return;
+            }
+            logger.warn({ err }, "Failed to refresh cleanup safety indicators");
+            const empty = new Map();
+            batch(() => {
+                setCleanupStatusByBranch(empty);
+                setBranchItems((items) => applyCleanupStatus(items, empty));
+            });
+        }
+        finally {
+            if (requestId === cleanupSafetyRequestId) {
+                setCleanupSafetyLoading(false);
+                setCleanupSafetyPending(new Set());
+            }
+        }
+    };
+    let logNotificationTimer = null;
+    let logTailTimer = null;
+    let branchFooterTimer = null;
+    const BRANCH_LOAD_TIMEOUT_MS = 3000;
+    const BRANCH_FULL_LOAD_TIMEOUT_MS = 8000;
+    const isHelpKey = (key) => {
+        if (key.ctrl || key.meta || key.super || key.hyper || key.option) {
+            return false;
+        }
+        return key.name === "h" || key.sequence === "h" || key.sequence === "?";
+    };
+    useKeyboard((key) => {
+        if (key.repeated) {
+            return;
+        }
+        if (helpVisible()) {
+            if (key.name === "escape" || isHelpKey(key)) {
+                setHelpVisible(false);
+            }
+            return;
+        }
+        if (isHelpKey(key)) {
+            setHelpVisible(true);
+        }
+    });
+    const navigateTo = (screen) => {
+        setScreenStack((prev) => [...prev, currentScreen()]);
+        setCurrentScreen(screen);
+    };
+    const goBack = () => {
+        const stack = screenStack();
+        if (stack.length === 0) {
+            return;
+        }
+        const previous = stack[stack.length - 1] ?? DEFAULT_SCREEN;
+        setScreenStack(stack.slice(0, -1));
+        // branch-list に戻る場合は選択状態をリセット
+        if (previous === "branch-list") {
+            setSelectedBranch(null);
+            setSelectedTool(null);
+            setSelectedMode("normal");
+            setIsNewBranch(false);
+            setNewBranchBaseRef(null);
+            setCreationSource(null);
+        }
+        setCurrentScreen(previous);
+    };
+    const openProfileError = (err, hint) => {
+        setProfileActionError(err instanceof Error ? err : new Error(String(err)));
+        setProfileActionHint(hint);
+        navigateTo("profile-error");
+    };
+    const showLogNotification = (message, tone) => {
+        setLogNotification({ message, tone });
+        if (logNotificationTimer) {
+            clearTimeout(logNotificationTimer);
+        }
+        logNotificationTimer = setTimeout(() => {
+            setLogNotification(null);
+        }, 2000);
+    };
+    const loadLogEntries = async (date) => {
+        const targetDate = date ?? getTodayLogDate();
+        setLogLoading(true);
+        setLogError(null);
+        try {
+            const target = logTarget();
+            if (!target.logDir) {
+                setLogEntries([]);
+                setLogSelectedDate(targetDate);
+                return;
+            }
+            const result = await readLogLinesForDate(target.logDir, targetDate);
+            if (!result) {
+                setLogEntries([]);
+                setLogSelectedDate(targetDate);
+                return;
+            }
+            setLogSelectedDate(result.date);
+            const parsed = parseLogLines(result.lines, { limit: 100 });
+            setLogEntries(parsed);
+        }
+        catch (err) {
+            setLogEntries([]);
+            setLogError(err instanceof Error ? err.message : "Failed to load logs");
+        }
+        finally {
+            setLogLoading(false);
+        }
+    };
+    const clearLogTailTimer = () => {
+        if (logTailTimer) {
+            clearInterval(logTailTimer);
+            logTailTimer = null;
+        }
+    };
+    const toggleLogTail = () => {
+        setLogTailEnabled((prev) => !prev);
+    };
+    const resetLogFiles = async () => {
+        const target = logTarget();
+        if (!target.logDir) {
+            showLogNotification("No logs available.", "error");
+            return;
+        }
+        try {
+            const cleared = await clearLogFiles(target.logDir);
+            if (cleared === 0) {
+                showLogNotification("No logs to reset.", "error");
+            }
+            else {
+                showLogNotification("Logs cleared.", "success");
+            }
+            await loadLogEntries(logSelectedDate());
+        }
+        catch (err) {
+            logger.warn({ err }, "Failed to clear log files");
+            showLogNotification("Failed to reset logs.", "error");
+        }
+    };
+    const refreshBranches = async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const repoRoot = await getRepositoryRoot();
+            const worktreesPromise = listAdditionalWorktrees();
+            const localBranchesPromise = getLocalBranches(repoRoot);
+            const currentBranchPromise = getCurrentBranch(repoRoot);
+            const lastToolUsagePromise = getLastToolUsageMap(repoRoot);
+            const [localBranches, currentBranch, worktrees, lastToolUsageMap] = await Promise.all([
+                withTimeout(localBranchesPromise, BRANCH_LOAD_TIMEOUT_MS).catch(() => []),
+                withTimeout(currentBranchPromise, BRANCH_LOAD_TIMEOUT_MS).catch(() => null),
+                withTimeout(worktreesPromise, BRANCH_LOAD_TIMEOUT_MS).catch(() => []),
+                withTimeout(lastToolUsagePromise, BRANCH_LOAD_TIMEOUT_MS).catch(() => new Map()),
+            ]);
+            if (currentBranch) {
+                localBranches.forEach((branch) => {
+                    if (branch.name === currentBranch) {
+                        branch.isCurrent = true;
+                    }
+                });
+            }
+            const initial = buildBranchList(localBranches, worktrees, lastToolUsageMap);
+            const initialItems = applyCleanupStatus(initial.items, cleanupStatusByBranch());
+            setBranchItems(initialItems);
+            setStats(buildStats(initialItems));
+            void refreshCleanupSafety();
+            void (async () => {
+                const [branches, latestWorktrees] = await Promise.all([
+                    withTimeout(getAllBranches(repoRoot), BRANCH_FULL_LOAD_TIMEOUT_MS).catch(() => localBranches),
+                    withTimeout(listAdditionalWorktrees(), BRANCH_FULL_LOAD_TIMEOUT_MS).catch(() => worktrees),
+                ]);
+                const full = buildBranchList(branches, latestWorktrees, lastToolUsageMap);
+                const fullItems = applyCleanupStatus(full.items, cleanupStatusByBranch());
+                setBranchItems(fullItems);
+                setStats(buildStats(fullItems));
+            })();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const refreshProfiles = async () => {
+        try {
+            const config = await loadProfiles();
+            setProfilesConfig(config);
+            const items = Object.entries(config.profiles ?? {}).map(([name, profile]) => ({
+                name,
+                displayName: profile.displayName,
+                isActive: config.activeProfile === name,
+            }));
+            items.sort((a, b) => a.name.localeCompare(b.name));
+            setProfileItems(items);
+            setActiveProfileName(config.activeProfile ?? null);
+            setProfileError(null);
+        }
+        catch (err) {
+            setProfilesConfig(null);
+            setProfileItems([]);
+            setActiveProfileName(null);
+            setProfileError(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+    createEffect(() => {
+        if (props.branches) {
+            const statusByBranch = cleanupStatusByBranch();
+            const nextItems = applyCleanupStatus(props.branches, statusByBranch);
+            setBranchItems(nextItems);
+            setStats(props.stats ?? buildStats(nextItems));
+            setLoading(false);
+        }
+    });
+    onMount(() => {
+        if (!props.branches) {
+            void refreshBranches();
+        }
+    });
+    onMount(() => {
+        if (props.branches) {
+            void refreshCleanupSafety();
+        }
+    });
+    onMount(() => {
+        if (props.version === undefined) {
+            void getPackageVersion()
+                .then((value) => setVersion(value ?? null))
+                .catch(() => setVersion(null));
+        }
+    });
+    onMount(() => {
+        void refreshProfiles();
+    });
+    onMount(() => {
+        void getConfig()
+            .then((config) => setDefaultBaseBranch(config.defaultBaseBranch))
+            .catch(() => setDefaultBaseBranch("main"));
+    });
+    // セッション履歴をロード（最終使用エージェントなど）
+    onMount(() => {
+        void getRepositoryRoot()
+            .then((repoRoot) => loadSession(repoRoot))
+            .then((session) => {
+            if (session?.history) {
+                setSessionHistory(session.history);
+            }
+        })
+            .catch(() => setSessionHistory([]));
+    });
+    onMount(() => {
+        void getAllCodingAgents()
+            .then((agents) => {
+            setToolItems(agents.map((agent) => ({
+                label: agent.displayName,
+                value: agent.id,
+            })));
+        })
+            .catch((err) => {
+            setToolItems([]);
+            setToolError(err instanceof Error ? err : new Error(String(err)));
+        });
+    });
+    // FR-028: Prefetch npm versions for all bunx-type agents at startup (background)
+    onMount(() => {
+        const bunxAgentIds = getBunxAgentIds();
+        void prefetchAgentVersions(bunxAgentIds).catch(() => {
+            // Silently handle errors - cache will return null and UI will show "latest" only
+        });
+    });
+    createEffect(() => {
+        if (currentScreen() === "log-list") {
+            logTarget();
+            void loadLogEntries(logSelectedDate());
+        }
+    });
+    createEffect(() => {
+        if (currentScreen() !== "log-list" || !logTailEnabled()) {
+            clearLogTailTimer();
+            return;
+        }
+        clearLogTailTimer();
+        logTailTimer = setInterval(() => {
+            void loadLogEntries(logSelectedDate());
+        }, 1500);
+    });
+    onCleanup(() => {
+        if (logNotificationTimer) {
+            clearTimeout(logNotificationTimer);
+        }
+        clearLogTailTimer();
+        if (branchFooterTimer) {
+            clearTimeout(branchFooterTimer);
+        }
+    });
+    const showBranchFooterMessage = (text, color, options) => {
+        if (branchFooterTimer) {
+            clearTimeout(branchFooterTimer);
+            branchFooterTimer = null;
+        }
+        setBranchFooterMessage({
+            text,
+            color,
+            ...(options?.spinning ? { isSpinning: true } : {}),
+        });
+        const timeout = options?.timeoutMs ?? 2000;
+        if (timeout > 0) {
+            branchFooterTimer = setTimeout(() => {
+                setBranchFooterMessage(null);
+            }, timeout);
+        }
+    };
+    const setCleanupIndicator = (branchName, indicator) => {
+        setCleanupIndicators((prev) => {
+            const next = { ...prev };
+            if (indicator) {
+                next[branchName] = indicator;
+            }
+            else {
+                delete next[branchName];
+            }
+            return next;
+        });
+    };
+    const handleBranchSelect = (branch) => {
+        setSelectedBranch(toSelectedBranchState(branch));
+        setIsNewBranch(false);
+        setNewBranchBaseRef(null);
+        setCreationSource(null);
+        setSelectedTool(null);
+        setSelectedMode("normal");
+        // FR-044: ウィザードポップアップをレイヤー表示
+        setWizardVisible(true);
+    };
+    const handleQuickCreate = (branch) => {
+        // 選択中のブランチをベースにウィザードを開始
+        if (branch) {
+            setSelectedBranch(toSelectedBranchState(branch));
+        }
+        setCreationSource(branch ? toSelectedBranchState(branch) : null);
+        setCreateBranchName("");
+        setSuppressCreateKey("n");
+        // FR-044: ウィザードポップアップをレイヤー表示（アクション選択から開始）
+        setWizardVisible(true);
+    };
+    // FR-049: Escapeキーでウィザードをキャンセル
+    const handleWizardClose = () => {
+        setWizardVisible(false);
+    };
+    // ウィザード完了時の処理
+    const handleWizardComplete = (result) => {
+        setWizardVisible(false);
+        const branch = selectedBranch();
+        if (!branch) {
+            return;
+        }
+        // 新規ブランチ作成の場合、ブランチ名を設定
+        const isCreatingNew = result.isNewBranch ?? false;
+        const finalBranchName = result.branchName
+            ? `${result.branchType ?? ""}${result.branchName}`
+            : branch.name;
+        // 新規作成時は選択中のブランチがベースとなる
+        const baseBranchRef = isCreatingNew ? branch.name : null;
+        const normalizedModel = normalizeModelId(result.tool, result.model);
+        exitApp({
+            branch: finalBranchName,
+            displayName: branch.displayName,
+            branchType: branch.branchType,
+            ...(branch.remoteBranch ? { remoteBranch: branch.remoteBranch } : {}),
+            ...(isCreatingNew
+                ? {
+                    isNewBranch: true,
+                    ...(baseBranchRef ? { baseBranch: baseBranchRef } : {}),
+                }
+                : {}),
+            tool: result.tool,
+            mode: result.mode,
+            skipPermissions: result.skipPermissions,
+            ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
+            ...(result.reasoningLevel !== undefined
+                ? { inferenceLevel: result.reasoningLevel }
+                : {}),
+            ...(result.toolVersion !== undefined
+                ? { toolVersion: result.toolVersion }
+                : {}),
+        });
+    };
+    // FR-010: クイックスタートからのResume（前回設定で続きから）
+    const handleWizardResume = (entry) => {
+        if (!entry.sessionId) {
+            handleWizardStartNew(entry);
+            return;
+        }
+        setWizardVisible(false);
+        const branch = selectedBranch();
+        if (!branch) {
+            return;
+        }
+        const normalizedModel = normalizeModelId(entry.toolId, entry.model ?? undefined);
+        exitApp({
+            branch: branch.name,
+            displayName: branch.displayName,
+            branchType: branch.branchType,
+            ...(branch.remoteBranch ? { remoteBranch: branch.remoteBranch } : {}),
+            tool: entry.toolId,
+            mode: "continue",
+            skipPermissions: entry.skipPermissions ?? false,
+            ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
+            ...(entry.reasoningLevel
+                ? { inferenceLevel: entry.reasoningLevel }
+                : {}),
+            ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
+            ...(entry.toolVersion !== undefined
+                ? { toolVersion: entry.toolVersion }
+                : {}),
+        });
+    };
+    // FR-010: クイックスタートからのStartNew（前回設定で新規）
+    const handleWizardStartNew = (entry) => {
+        setWizardVisible(false);
+        const branch = selectedBranch();
+        if (!branch) {
+            return;
+        }
+        const normalizedModel = normalizeModelId(entry.toolId, entry.model ?? undefined);
+        exitApp({
+            branch: branch.name,
+            displayName: branch.displayName,
+            branchType: branch.branchType,
+            ...(branch.remoteBranch ? { remoteBranch: branch.remoteBranch } : {}),
+            tool: entry.toolId,
+            mode: "normal",
+            skipPermissions: entry.skipPermissions ?? false,
+            ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
+            ...(entry.reasoningLevel
+                ? { inferenceLevel: entry.reasoningLevel }
+                : {}),
+            ...(entry.toolVersion !== undefined
+                ? { toolVersion: entry.toolVersion }
+                : {}),
+        });
+    };
+    const buildSkipNotice = (skip, unsafeLabel) => {
+        const parts = [];
+        if (skip.unsafe > 0) {
+            parts.push(`${skip.unsafe} ${unsafeLabel}`);
+        }
+        if (skip.protected > 0) {
+            parts.push(`${skip.protected} protected`);
+        }
+        if (skip.remote > 0) {
+            parts.push(`${skip.remote} remote-only`);
+        }
+        if (skip.current > 0) {
+            parts.push(`${skip.current} current`);
+        }
+        if (parts.length === 0) {
+            return null;
+        }
+        return `Skipped branches: ${parts.join(", ")}.`;
+    };
+    const handleCleanupCommand = async () => {
+        if (branchInputLocked()) {
+            return;
+        }
+        const selection = selectedBranches();
+        const hasSelection = selection.length > 0;
+        const skipCounts = {
+            unsafe: 0,
+            protected: 0,
+            remote: 0,
+            current: 0,
+        };
+        setBranchInputLocked(true);
+        setCleanupIndicators({});
+        showBranchFooterMessage(hasSelection
+            ? "Preparing cleanup..."
+            : "Scanning for cleanup candidates...", "yellow", { spinning: true, timeoutMs: 0 });
+        try {
+            const tasks = [];
+            if (hasSelection) {
+                const branchMap = new Map(branchItems().map((branch) => [branch.name, branch]));
+                for (const branchName of selection) {
+                    const branch = branchMap.get(branchName);
+                    if (!branch) {
+                        continue;
+                    }
+                    if (branch.type === "remote") {
+                        skipCounts.remote += 1;
+                        continue;
+                    }
+                    if (branch.isCurrent) {
+                        skipCounts.current += 1;
+                        continue;
+                    }
+                    const worktreePath = branch.worktree?.path ?? null;
+                    const cleanupType = worktreePath
+                        ? "worktree-and-branch"
+                        : "branch-only";
+                    const baseTask = {
+                        branch: branch.name,
+                        worktreePath,
+                        cleanupType,
+                    };
+                    const isAccessible = branch.worktree?.isAccessible;
+                    tasks.push(isAccessible === undefined
+                        ? baseTask
+                        : { ...baseTask, isAccessible });
+                }
+            }
+            else {
+                // FR-028: 選択が0件の場合は警告を表示して処理をスキップ
+                setBranchInputLocked(false);
+                showBranchFooterMessage("No branches selected.", "yellow");
+                return;
+            }
+            const skipNotice = buildSkipNotice(skipCounts, hasSelection
+                ? "unsafe (uncommitted/unpushed, unmerged, or missing upstream)"
+                : "with uncommitted or unpushed changes");
+            if (tasks.length === 0) {
+                const baseMessage = hasSelection
+                    ? "No eligible branches selected for cleanup."
+                    : "No cleanup candidates found.";
+                showBranchFooterMessage(skipNotice ? `${baseMessage} ${skipNotice}` : baseMessage, "yellow");
+                return;
+            }
+            setCleanupIndicators(() => {
+                const next = {};
+                tasks.forEach((task) => {
+                    next[task.branch] = {
+                        icon: "-",
+                        isSpinning: true,
+                        color: "yellow",
+                    };
+                });
+                return next;
+            });
+            showBranchFooterMessage(`Cleaning up ${tasks.length} branch(es)...`, "yellow", { spinning: true, timeoutMs: 0 });
+            let successCount = 0;
+            let failedCount = 0;
+            for (const task of tasks) {
+                try {
+                    if (task.cleanupType === "worktree-and-branch" && task.worktreePath) {
+                        await removeWorktree(task.worktreePath, task.isAccessible === false);
+                    }
+                    await deleteBranch(task.branch, true);
+                    setCleanupIndicator(task.branch, { icon: "v", color: "green" });
+                    successCount += 1;
+                }
+                catch {
+                    setCleanupIndicator(task.branch, { icon: "x", color: "red" });
+                    failedCount += 1;
+                }
+            }
+            setSelectedBranches([]);
+            await refreshBranches();
+            const skippedTotal = skipCounts.unsafe +
+                skipCounts.protected +
+                skipCounts.remote +
+                skipCounts.current;
+            const summaryParts = [`${successCount} cleaned`];
+            if (failedCount > 0) {
+                summaryParts.push(`${failedCount} failed`);
+            }
+            if (skippedTotal > 0) {
+                summaryParts.push(`${skippedTotal} skipped`);
+            }
+            const summary = `Cleanup finished: ${summaryParts.join(", ")}.`;
+            const message = skipNotice ? `${summary} ${skipNotice}` : summary;
+            showBranchFooterMessage(message, failedCount > 0 ? "red" : "green");
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            showBranchFooterMessage(`Cleanup failed: ${errorMessage}`, "red");
+        }
+        finally {
+            setBranchInputLocked(false);
+        }
+    };
+    const handleRepairWorktrees = async () => {
+        if (branchInputLocked()) {
+            return;
+        }
+        // FR-002/FR-007: 選択済みブランチのみを対象とする
+        const selection = selectedBranches();
+        if (selection.length === 0) {
+            showBranchFooterMessage("No branches selected.", "yellow");
+            return;
+        }
+        // 選択されたローカルブランチのうち、Worktreeを持つものを修復対象とする
+        const selectionSet = new Set(selection);
+        const targets = branchItems()
+            .filter((branch) => selectionSet.has(branch.name) &&
+            branch.type !== "remote" &&
+            branch.worktreeStatus !== undefined)
+            .map((branch) => branch.name);
+        if (targets.length === 0) {
+            showBranchFooterMessage("No worktrees to repair.", "yellow");
+            return;
+        }
+        setBranchInputLocked(true);
+        showBranchFooterMessage("Repairing worktrees...", "yellow", {
+            spinning: true,
+            timeoutMs: 0,
+        });
+        try {
+            const result = await repairWorktrees(targets);
+            await refreshBranches();
+            // エラー詳細をログに出力
+            if (result.failedCount > 0) {
+                logger.error({ failures: result.failures, targets }, "Worktree repair failed for some branches");
+            }
+            const message = result.failedCount > 0
+                ? `Repair finished: ${result.repairedCount} repaired, ${result.failedCount} failed.`
+                : result.repairedCount > 0
+                    ? `Repaired ${result.repairedCount} worktree(s).`
+                    : "No worktrees repaired.";
+            showBranchFooterMessage(message, result.failedCount > 0 ? "red" : "green");
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            logger.error({ error: err, targets }, "Worktree repair threw an error");
+            showBranchFooterMessage(`Repair failed: ${errorMessage}`, "red");
+        }
+        finally {
+            setBranchInputLocked(false);
+        }
+    };
+    const openProfileCreate = () => {
+        setProfileInputMode("create-profile");
+        setProfileInputValue("");
+        setProfileEnvKey(null);
+        setProfileInputSuppressKey("n");
+        navigateTo("profile-input");
+    };
+    const openProfileDelete = (profile) => {
+        setSelectedProfileName(profile.name);
+        setProfileConfirmMode("delete-profile");
+        navigateTo("profile-confirm");
+    };
+    const openProfileEnv = (profile) => {
+        setSelectedProfileName(profile.name);
+        navigateTo("profile-env");
+    };
+    const openProfileEnvAdd = () => {
+        setProfileInputMode("add-env");
+        setProfileInputValue("");
+        setProfileEnvKey(null);
+        setProfileInputSuppressKey("a");
+        navigateTo("profile-input");
+    };
+    const openProfileEnvEdit = (variable) => {
+        setProfileInputMode("edit-env");
+        setProfileEnvKey(variable.key);
+        setProfileInputValue(variable.value);
+        setProfileInputSuppressKey("e");
+        navigateTo("profile-input");
+    };
+    const openProfileEnvDelete = (variable) => {
+        setProfileConfirmMode("delete-env");
+        setProfileEnvKey(variable.key);
+        navigateTo("profile-confirm");
+    };
+    const handleProfileInputChange = (value) => {
+        const suppressKey = profileInputSuppressKey();
+        if (suppressKey && profileInputValue() === "" && value === suppressKey) {
+            setProfileInputSuppressKey(null);
+            setProfileInputValue("");
+            return;
+        }
+        setProfileInputSuppressKey(null);
+        setProfileInputValue(value);
+    };
+    const submitProfileInput = async (value) => {
+        const mode = profileInputMode();
+        const trimmed = value.trim();
+        if (mode === "create-profile") {
+            if (!trimmed) {
+                openProfileError(new Error("Profile name is required."), "Invalid name.");
+                return;
+            }
+            if (!isValidProfileName(trimmed)) {
+                openProfileError(new Error(`Invalid profile name: "${trimmed}".`), "Profile names must use lowercase letters, numbers, and hyphens.");
+                return;
+            }
+            try {
+                await createProfile(trimmed, { displayName: trimmed, env: {} });
+                await refreshProfiles();
+                setSelectedProfileName(trimmed);
+                setProfileInputValue("");
+                setProfileInputSuppressKey(null);
+                goBack();
+            }
+            catch (err) {
+                openProfileError(err, "Unable to create profile.");
+            }
+            return;
+        }
+        const entry = selectedProfileConfig();
+        if (!entry) {
+            openProfileError(new Error("Profile not selected."), "Profile not found.");
+            return;
+        }
+        if (mode === "add-env") {
+            const separatorIndex = trimmed.indexOf("=");
+            if (separatorIndex <= 0) {
+                openProfileError(new Error("Environment variable must be in KEY=VALUE format."), "Invalid environment variable.");
+                return;
+            }
+            const key = trimmed.slice(0, separatorIndex).trim();
+            const valuePart = trimmed.slice(separatorIndex + 1);
+            if (!key) {
+                openProfileError(new Error("Environment variable key is required."), "Invalid environment variable.");
+                return;
+            }
+            const nextEnv = { ...(entry.profile.env ?? {}) };
+            nextEnv[key] = valuePart;
+            try {
+                await updateProfile(entry.name, { env: nextEnv });
+                await refreshProfiles();
+                setProfileInputValue("");
+                setProfileInputSuppressKey(null);
+                goBack();
+            }
+            catch (err) {
+                openProfileError(err, "Unable to update profile.");
+            }
+            return;
+        }
+        if (mode === "edit-env") {
+            const envKey = profileEnvKey();
+            if (!envKey) {
+                openProfileError(new Error("Environment variable not selected."), "Select a variable to edit.");
+                return;
+            }
+            const nextEnv = { ...(entry.profile.env ?? {}) };
+            nextEnv[envKey] = value;
+            try {
+                await updateProfile(entry.name, { env: nextEnv });
+                await refreshProfiles();
+                setProfileInputValue("");
+                setProfileInputSuppressKey(null);
+                goBack();
+            }
+            catch (err) {
+                openProfileError(err, "Unable to update profile.");
+            }
+        }
+    };
+    const confirmProfileAction = async (confirmed) => {
+        if (!confirmed) {
+            goBack();
+            return;
+        }
+        const mode = profileConfirmMode();
+        const entry = selectedProfileConfig();
+        if (mode === "delete-profile") {
+            const name = selectedProfileName();
+            if (!name) {
+                openProfileError(new Error("Profile not selected."), "Profile not found.");
+                return;
+            }
+            try {
+                await deleteProfile(name);
+                await refreshProfiles();
+                setProfileEnvKey(null);
+                goBack();
+            }
+            catch (err) {
+                openProfileError(err, "Unable to delete profile.");
+            }
+            return;
+        }
+        if (mode === "delete-env") {
+            if (!entry) {
+                openProfileError(new Error("Profile not selected."), "Profile not found.");
+                return;
+            }
+            const envKey = profileEnvKey();
+            if (!envKey) {
+                openProfileError(new Error("Environment variable not selected."), "Select a variable to delete.");
+                return;
+            }
+            const nextEnv = { ...(entry.profile.env ?? {}) };
+            delete nextEnv[envKey];
+            try {
+                await updateProfile(entry.name, { env: nextEnv });
+                await refreshProfiles();
+                setProfileEnvKey(null);
+                goBack();
+            }
+            catch (err) {
+                openProfileError(err, "Unable to update profile.");
+            }
+        }
+    };
+    const toggleSelectedBranch = (branchName) => {
+        if (unsafeSelectionConfirmVisible()) {
+            return;
+        }
+        const currentSelection = new Set(selectedBranches());
+        if (currentSelection.has(branchName)) {
+            currentSelection.delete(branchName);
+            setSelectedBranches(Array.from(currentSelection));
+            return;
+        }
+        const branch = branchItems().find((item) => item.name === branchName);
+        const pending = cleanupSafetyPending();
+        const hasSafetyPending = pending.has(branchName);
+        const hasUncommitted = branch?.worktree?.hasUncommittedChanges === true;
+        const hasUnpushed = branch?.hasUnpushedCommits === true;
+        const isUnmerged = branch?.isUnmerged === true;
+        const safeToCleanup = branch?.safeToCleanup === true;
+        const isRemoteBranch = branch?.type === "remote";
+        const isUnsafe = Boolean(branch) &&
+            !isRemoteBranch &&
+            !hasSafetyPending &&
+            (hasUncommitted || hasUnpushed || isUnmerged || !safeToCleanup);
+        if (branch && isUnsafe) {
+            setUnsafeSelectionTarget(branch.name);
+            setUnsafeSelectionConfirmVisible(true);
+            return;
+        }
+        currentSelection.add(branchName);
+        setSelectedBranches(Array.from(currentSelection));
+    };
+    const confirmUnsafeSelection = (confirmed) => {
+        suppressBranchInputOnce();
+        const target = unsafeSelectionTarget();
+        setUnsafeSelectionConfirmVisible(false);
+        setUnsafeSelectionTarget(null);
+        if (!confirmed || !target) {
+            return;
+        }
+        setSelectedBranches((prev) => prev.includes(target) ? prev : [...prev, target]);
+    };
+    const handleToolSelect = (item) => {
+        setSelectedTool(item.value);
+        navigateTo("mode-select");
+    };
+    const handleModeSelect = (item) => {
+        setSelectedMode(item.value);
+        navigateTo("skip-permissions");
+    };
+    const finalizeSelection = (skipPermissions) => {
+        const branch = selectedBranch();
+        const tool = selectedTool();
+        if (!branch || !tool) {
+            return;
+        }
+        const defaultModel = getDefaultModelOption(tool);
+        const resolvedModel = defaultModel?.id ?? null;
+        const normalizedModel = normalizeModelId(tool, resolvedModel);
+        const resolvedInference = getDefaultInferenceForModel(defaultModel);
+        const baseRef = newBranchBaseRef();
+        exitApp({
+            branch: branch.name,
+            displayName: branch.displayName,
+            branchType: branch.branchType,
+            ...(branch.remoteBranch ? { remoteBranch: branch.remoteBranch } : {}),
+            ...(isNewBranch()
+                ? {
+                    isNewBranch: true,
+                    ...(baseRef ? { baseBranch: baseRef } : {}),
+                }
+                : {}),
+            tool,
+            mode: selectedMode(),
+            skipPermissions,
+            ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
+            ...(resolvedInference !== undefined
+                ? { inferenceLevel: resolvedInference }
+                : {}),
+        });
+    };
+    const renderCurrentScreen = () => {
+        const screen = currentScreen();
+        if (screen === "branch-list") {
+            const cleanupUI = {
+                indicators: cleanupIndicators(),
+                footerMessage: branchFooterMessage(),
+                inputLocked: branchInputLocked() || unsafeConfirmInputLocked(),
+                safetyLoading: cleanupSafetyLoading(),
+                safetyPendingBranches: cleanupSafetyPending(),
+            };
+            return (_jsx(BranchListScreen, { branches: branchItems(), stats: stats(), onSelect: handleBranchSelect, onQuit: () => exitApp(undefined), onCleanupCommand: handleCleanupCommand, onRefresh: refreshBranches, onRepairWorktrees: handleRepairWorktrees, loading: loading(), error: error(), loadingIndicatorDelay: props.loadingIndicatorDelay ?? 0, lastUpdated: stats().lastUpdated, version: version(), workingDirectory: workingDirectory(), activeProfile: activeProfile(), onOpenLogs: (branch) => {
+                    setLogTargetBranch(branch);
+                    setLogSelectedEntry(null);
+                    setLogSelectedDate(getTodayLogDate());
+                    setLogTailEnabled(false);
+                    navigateTo("log-list");
+                }, onOpenProfiles: () => navigateTo("profile"), selectedBranches: selectedBranches(), onToggleSelect: toggleSelectedBranch, onCreateBranch: handleQuickCreate, cleanupUI: cleanupUI, helpVisible: helpVisible(), wizardVisible: wizardVisible(), confirmVisible: unsafeSelectionConfirmVisible(), cursorPosition: branchCursorPosition(), onCursorPositionChange: setBranchCursorPosition }));
+        }
+        if (screen === "tool-select") {
+            if (toolError()) {
+                return (_jsx(ErrorScreen, { error: toolError(), onBack: goBack, hint: "Unable to load available tools." }));
+            }
+            return (_jsx(SelectorScreen, { title: "Select tool", items: toolItems(), onSelect: handleToolSelect, onBack: goBack, helpVisible: helpVisible() }));
+        }
+        if (screen === "mode-select") {
+            return (_jsx(SelectorScreen, { title: "Execution mode", items: [
+                    { label: "Normal", value: "normal" },
+                    { label: "Continue", value: "continue" },
+                    { label: "Resume", value: "resume" },
+                ], onSelect: handleModeSelect, onBack: goBack, helpVisible: helpVisible() }));
+        }
+        if (screen === "skip-permissions") {
+            return (_jsx(SelectorScreen, { title: "Skip permission prompts?", items: [
+                    { label: "Yes", value: "true" },
+                    { label: "No", value: "false" },
+                ], onSelect: (item) => finalizeSelection(item.value === "true"), onBack: goBack, helpVisible: helpVisible() }));
+        }
+        if (screen === "log-list") {
+            return (_jsx(LogScreen, { entries: logEntries(), loading: logLoading(), error: logError(), onBack: goBack, onSelect: (entry) => {
+                    setLogSelectedEntry(entry);
+                    navigateTo("log-detail");
+                }, onCopy: async (entry) => {
+                    try {
+                        await copyToClipboard(entry.json);
+                        showLogNotification("Copied to clipboard.", "success");
+                    }
+                    catch {
+                        showLogNotification("Failed to copy to clipboard.", "error");
+                    }
+                }, onReload: () => void loadLogEntries(logSelectedDate()), onToggleTail: toggleLogTail, onReset: () => void resetLogFiles(), notification: logNotification(), version: version(), selectedDate: logSelectedDate(), branchLabel: logBranchLabel(), sourceLabel: logSourceLabel(), tailing: logTailEnabled(), helpVisible: helpVisible() }));
+        }
+        if (screen === "log-detail") {
+            return (_jsx(LogDetailScreen, { entry: logSelectedEntry(), onBack: goBack, onCopy: async (entry) => {
+                    try {
+                        await copyToClipboard(entry.json);
+                        showLogNotification("Copied to clipboard.", "success");
+                    }
+                    catch {
+                        showLogNotification("Failed to copy to clipboard.", "error");
+                    }
+                }, notification: logNotification(), version: version(), helpVisible: helpVisible() }));
+        }
+        if (screen === "profile") {
+            if (profileError()) {
+                return (_jsx(ErrorScreen, { error: profileError(), onBack: goBack, hint: "Unable to load profiles." }));
+            }
+            return (_jsx(ProfileScreen, { profiles: profileItems(), version: version(), helpVisible: helpVisible(), onCreate: openProfileCreate, onDelete: openProfileDelete, onEdit: openProfileEnv, onSelect: (profile) => {
+                    void setActiveProfile(profile.name)
+                        .then(() => {
+                        void refreshProfiles();
+                    })
+                        .catch((err) => {
+                        openProfileError(err, "Unable to set active profile.");
+                    });
+                }, onBack: goBack }));
+        }
+        if (screen === "profile-env") {
+            const entry = selectedProfileConfig();
+            if (!entry) {
+                return (_jsx(ErrorScreen, { error: "Profile not found.", onBack: goBack, hint: "Select a profile before editing." }));
+            }
+            return (_jsx(ProfileEnvScreen, { profileName: entry.name, variables: profileEnvVariables(), onAdd: openProfileEnvAdd, onEdit: openProfileEnvEdit, onDelete: openProfileEnvDelete, onViewOsEnv: () => navigateTo("profile-os-env"), onBack: goBack, version: version(), helpVisible: helpVisible() }));
+        }
+        if (screen === "profile-input") {
+            const mode = profileInputMode();
+            const envKey = profileEnvKey();
+            const message = mode === "create-profile"
+                ? "New profile name"
+                : mode === "add-env"
+                    ? "Add environment variable"
+                    : `Edit value for ${envKey ?? "(unknown)"}`;
+            const label = mode === "create-profile"
+                ? "Profile name"
+                : mode === "add-env"
+                    ? "KEY=VALUE"
+                    : "Value";
+            const placeholder = mode === "create-profile"
+                ? "development"
+                : mode === "add-env"
+                    ? "MY_VAR=value"
+                    : undefined;
+            return (_jsx(InputScreen, { message: message, value: profileInputValue(), onChange: handleProfileInputChange, onSubmit: (value) => void submitProfileInput(value), onCancel: () => {
+                    setProfileInputSuppressKey(null);
+                    goBack();
+                }, label: label, ...(placeholder !== undefined ? { placeholder } : {}), width: 32, helpVisible: helpVisible() }));
+        }
+        if (screen === "profile-confirm") {
+            const mode = profileConfirmMode();
+            const profileName = selectedProfileName();
+            const envKey = profileEnvKey();
+            const message = mode === "delete-profile"
+                ? `Delete profile ${profileName ?? "(unknown)"}?`
+                : `Delete ${envKey ?? "(unknown)"}?`;
+            return (_jsx(ConfirmScreen, { message: message, onConfirm: (confirmed) => void confirmProfileAction(confirmed), defaultNo: true, helpVisible: helpVisible() }));
+        }
+        if (screen === "profile-os-env") {
+            const highlightKeys = profileEnvVariables().map((variable) => variable.key);
+            return (_jsx(EnvironmentScreen, { variables: osEnvVariables(), highlightKeys: highlightKeys, onBack: goBack, version: version(), helpVisible: helpVisible() }));
+        }
+        if (screen === "profile-error") {
+            return (_jsx(ErrorScreen, { error: profileActionError() ?? "Profile error", onBack: () => {
+                    setProfileActionError(null);
+                    setProfileActionHint(null);
+                    goBack();
+                }, ...(profileActionHint()
+                    ? { hint: profileActionHint() }
+                    : {}), helpVisible: helpVisible() }));
+        }
+        if (screen === "worktree-create") {
+            const baseBranchRef = resolveBaseBranchRef(creationSource(), null, () => defaultBaseBranch());
+            const baseBranchLabel = resolveBaseBranchLabel(creationSource(), null, () => defaultBaseBranch());
+            return (_jsx(WorktreeCreateScreen, { branchName: createBranchName(), baseBranch: baseBranchLabel, version: version(), helpVisible: helpVisible(), onChange: (value) => {
+                    const suppressKey = suppressCreateKey();
+                    if (suppressKey &&
+                        createBranchName() === "" &&
+                        value === suppressKey) {
+                        setSuppressCreateKey(null);
+                        setCreateBranchName("");
+                        return;
+                    }
+                    setSuppressCreateKey(null);
+                    setCreateBranchName(value);
+                }, onSubmit: (value, branchType) => {
+                    const trimmed = value.trim();
+                    if (!trimmed) {
+                        return;
+                    }
+                    // Add prefix based on selected branch type
+                    const prefixKey = branchType.toUpperCase();
+                    const prefix = BRANCH_PREFIXES[prefixKey] ?? "";
+                    const fullBranchName = `${prefix}${trimmed}`;
+                    setSelectedBranch({
+                        name: fullBranchName,
+                        displayName: fullBranchName,
+                        branchType: "local",
+                        branchCategory: branchType,
+                    });
+                    setIsNewBranch(true);
+                    setNewBranchBaseRef(baseBranchRef);
+                    setSelectedTool(null);
+                    setSelectedMode("normal");
+                    setSuppressCreateKey(null);
+                    navigateTo("tool-select");
+                }, onCancel: () => {
+                    setSuppressCreateKey(null);
+                    goBack();
+                } }));
+        }
+        if (screen === "loading") {
+            return (_jsx(LoadingIndicatorScreen, { message: "Loading...", delay: props.loadingIndicatorDelay ?? 0 }));
+        }
+        if (screen === "error") {
+            return (_jsx(ErrorScreen, { error: error() ?? "Unknown error", helpVisible: helpVisible() }));
+        }
+        return (_jsx(ErrorScreen, { error: `Unknown screen: ${screen}`, onBack: goBack, helpVisible: helpVisible() }));
+    };
+    return (_jsxs(_Fragment, { children: [renderCurrentScreen(), unsafeSelectionConfirmVisible() && (_jsx("box", { position: "absolute", top: "30%", left: "20%", width: unsafeConfirmBoxWidth(), zIndex: 110, border: true, borderStyle: "single", borderColor: "yellow", backgroundColor: "black", padding: 1, children: _jsx(ConfirmScreen, { message: UNSAFE_SELECTION_MESSAGE, onConfirm: confirmUnsafeSelection, yesLabel: "OK", noLabel: "Cancel", defaultNo: true, helpVisible: helpVisible(), width: unsafeConfirmContentWidth() }) })), _jsx(HelpOverlay, { visible: helpVisible(), context: currentScreen() }), _jsx(WizardController, { visible: wizardVisible(), selectedBranchName: selectedBranch()?.name ?? "", history: quickStartHistory(), onClose: handleWizardClose, onComplete: handleWizardComplete, onResume: handleWizardResume, onStartNew: handleWizardStartNew })] }));
+}
+const withTimeout = async (promise, timeoutMs) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+        reject(new Error("timeout"));
+    }, timeoutMs);
+    promise
+        .then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+    })
+        .catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+    });
+});
+const buildBranchList = (branches, worktrees, lastToolUsageMap) => {
+    const localBranchNames = new Set(branches.filter((branch) => branch.type === "local").map((b) => b.name));
+    const filtered = branches.filter((branch) => {
+        if (branch.type === "remote") {
+            const remoteName = branch.name.replace(/^origin\//, "");
+            return !localBranchNames.has(remoteName);
+        }
+        return true;
+    });
+    const worktreeMap = new Map();
+    for (const worktree of worktrees) {
+        worktreeMap.set(worktree.branch, {
+            path: worktree.path,
+            locked: worktree.locked ?? false,
+            prunable: worktree.prunable ?? false,
+            isAccessible: worktree.isAccessible ?? true,
+            ...(worktree.hasUncommittedChanges !== undefined
+                ? { hasUncommittedChanges: worktree.hasUncommittedChanges }
+                : {}),
+        });
+    }
+    const enriched = filtered.map((branch) => {
+        const lastToolUsage = lastToolUsageMap?.get(branch.name);
+        const baseBranch = lastToolUsage ? { ...branch, lastToolUsage } : branch;
+        if (branch.type === "local") {
+            const worktree = worktreeMap.get(branch.name);
+            if (worktree) {
+                return { ...baseBranch, worktree };
+            }
+        }
+        return baseBranch;
+    });
+    const items = formatBranchItems(enriched, worktreeMap);
+    return { items, worktreeMap };
+};
+//# sourceMappingURL=App.solid.js.map