git-watchtower 1.2.0 → 1.3.0

package/README.md

@@ -198,6 +198,28 @@ GIT_POLL_INTERVAL=10000 git-watchtower
 | `u` | Undo last branch switch |
 | `p` | Force pull current branch |
 | `f` | Fetch all branches + refresh sparklines |
+| `b` | Branch actions modal (see below) |
+
+### Branch Actions (`b`)
+
+Press `b` on any branch to open an interactive action modal. All actions are always visible — unavailable ones are grayed out with reasons (e.g., "Requires gh CLI", "Run: gh auth login").
+
+| Key | Action | Requires |
+|-----|--------|----------|
+| `b` | Open branch on GitHub/GitLab/Bitbucket/Azure DevOps | - |
+| `c` | Open Claude Code session in browser | Claude branch with session URL |
+| `p` | Create PR (or view existing PR) | `gh` or `glab` CLI |
+| `d` | View PR diff on GitHub/GitLab | Open PR |
+| `a` | Approve pull request | `gh` or `glab` CLI + open PR |
+| `m` | Merge pull request (squash + delete branch) | `gh` or `glab` CLI + open PR |
+| `i` | Check CI status | `gh` or `glab` CLI |
+| `Esc` | Close modal | - |
+
+The modal opens instantly and loads PR info in the background. Results are cached per branch and invalidated when the branch receives new commits. The modal auto-detects:
+- **Claude Code branches** (`claude/` prefix) and extracts session URLs from commit messages
+- **Git hosting platform** from the remote URL (GitHub, GitLab, Bitbucket, Azure DevOps)
+- **Existing PRs** and their review/CI status
+- **CLI tool availability** — shows install/auth hints when `gh` or `glab` isn't set up
 
 ### Server Controls
 | Key | Mode | Action |

package/bin/git-watchtower.js

@@ -43,6 +43,7 @@
  *   R       - Restart dev server (command mode)
  *   l       - View server logs (command mode)
  *   o       - Open live server in browser
+ *   b       - Branch actions (open on GitHub, Claude session, create/approve/merge PR, CI)
  *   f       - Fetch all branches + refresh sparklines
  *   s       - Toggle sound notifications
  *   c       - Toggle casino mode (Vegas-style feedback)
@@ -65,119 +66,34 @@ const casinoSounds = require('../src/casino/sounds');
 // Gitignore utilities for file watcher
 const { loadGitignorePatterns, shouldIgnoreFile } = require('../src/utils/gitignore');
 
-// Package info for --version
-const PACKAGE_VERSION = '1.0.0';
+// Extracted modules
+const { formatTimeAgo } = require('../src/utils/time');
+const { openInBrowser: openUrl } = require('../src/utils/browser');
+const { playSound: playSoundEffect } = require('../src/utils/sound');
+const { parseArgs: parseCliArgs, applyCliArgsToConfig: mergeCliArgs, getHelpText, PACKAGE_VERSION } = require('../src/cli/args');
+const { parseRemoteUrl, buildBranchUrl, detectPlatform, buildWebUrl, extractSessionUrl } = require('../src/git/remote');
+const { parseGitHubPr, parseGitLabMr, parseGitHubPrList, parseGitLabMrList, isBaseBranch } = require('../src/git/pr');
 
 // ============================================================================
-// Security & Validation
+// Security & Validation (imported from src/git/branch.js and src/git/commands.js)
 // ============================================================================
-
-// Valid git branch name pattern (conservative)
-const VALID_BRANCH_PATTERN = /^[a-zA-Z0-9_\-./]+$/;
-
-function isValidBranchName(name) {
-  if (!name || typeof name !== 'string') return false;
-  if (name.length > 255) return false;
-  if (!VALID_BRANCH_PATTERN.test(name)) return false;
-  // Reject dangerous patterns
-  if (name.includes('..')) return false;
-  if (name.startsWith('-')) return false;
-  if (name.startsWith('/') || name.endsWith('/')) return false;
-  return true;
-}
-
-function sanitizeBranchName(name) {
-  if (!isValidBranchName(name)) {
-    throw new Error(`Invalid branch name: ${name}`);
-  }
-  return name;
-}
-
-async function checkGitAvailable() {
-  return new Promise((resolve) => {
-    exec('git --version', (error) => {
-      resolve(!error);
-    });
-  });
-}
+const { isValidBranchName, sanitizeBranchName } = require('../src/git/branch');
+const { isGitAvailable: checkGitAvailable } = require('../src/git/commands');
 
 // ============================================================================
-// Configuration File Support
+// Configuration (imports from src/config/, inline wizard kept here)
 // ============================================================================
+const { getDefaultConfig, migrateConfig } = require('../src/config/schema');
+const { getConfigPath, loadConfig: loadConfigFile, saveConfig: saveConfigFile, CONFIG_FILE_NAME } = require('../src/config/loader');
 
-const CONFIG_FILE_NAME = '.watchtowerrc.json';
 const PROJECT_ROOT = process.cwd();
 
-function getConfigPath() {
-  return path.join(PROJECT_ROOT, CONFIG_FILE_NAME);
-}
-
 function loadConfig() {
-  const configPath = getConfigPath();
-  if (fs.existsSync(configPath)) {
-    try {
-      const content = fs.readFileSync(configPath, 'utf8');
-      return JSON.parse(content);
-    } catch (e) {
-      console.error(`Warning: Could not parse ${CONFIG_FILE_NAME}: ${e.message}`);
-      return null;
-    }
-  }
-  return null;
+  return loadConfigFile(PROJECT_ROOT);
 }
 
 function saveConfig(config) {
-  const configPath = getConfigPath();
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-}
-
-function getDefaultConfig() {
-  return {
-    // Server settings
-    server: {
-      mode: 'static',           // 'static' | 'command' | 'none'
-      staticDir: 'public',      // Directory for static mode
-      command: '',              // Command for command mode (e.g., 'npm run dev')
-      port: 3000,               // Port for static mode / display for command mode
-      restartOnSwitch: true,    // Restart server on branch switch (command mode)
-    },
-    // Git settings
-    remoteName: 'origin',       // Git remote name
-    autoPull: true,             // Auto-pull when current branch has updates
-    gitPollInterval: 5000,      // Polling interval in ms
-    // UI settings
-    soundEnabled: true,
-    visibleBranches: 7,
-  };
-}
-
-// Migrate old config format to new format
-function migrateConfig(config) {
-  if (config.server) return config; // Already new format
-
-  // Convert old format to new
-  const newConfig = getDefaultConfig();
-
-  if (config.noServer) {
-    newConfig.server.mode = 'none';
-  }
-  if (config.port) {
-    newConfig.server.port = config.port;
-  }
-  if (config.staticDir) {
-    newConfig.server.staticDir = config.staticDir;
-  }
-  if (config.gitPollInterval) {
-    newConfig.gitPollInterval = config.gitPollInterval;
-  }
-  if (typeof config.soundEnabled === 'boolean') {
-    newConfig.soundEnabled = config.soundEnabled;
-  }
-  if (config.visibleBranches) {
-    newConfig.visibleBranches = config.visibleBranches;
-  }
-
-  return newConfig;
+  saveConfigFile(config, PROJECT_ROOT);
 }
 
 async function promptUser(question, defaultValue = '') {
@@ -401,7 +317,7 @@ async function ensureConfig(cliArgs) {
   // Check if --init flag was passed (force reconfiguration)
   if (cliArgs.init) {
     const config = await runConfigurationWizard();
-    return applyCliArgsToConfig(config, cliArgs);
+    return mergeCliArgs(config, cliArgs);
   }
 
   // Load existing config
@@ -423,191 +339,16 @@ async function ensureConfig(cliArgs) {
   }
 
   // Merge CLI args over config (CLI takes precedence)
-  return applyCliArgsToConfig(config, cliArgs);
-}
-
-function applyCliArgsToConfig(config, cliArgs) {
-  // Server settings
-  if (cliArgs.mode !== null) {
-    config.server.mode = cliArgs.mode;
-  }
-  if (cliArgs.noServer) {
-    config.server.mode = 'none';
-  }
-  if (cliArgs.port !== null) {
-    config.server.port = cliArgs.port;
-  }
-  if (cliArgs.staticDir !== null) {
-    config.server.staticDir = cliArgs.staticDir;
-  }
-  if (cliArgs.command !== null) {
-    config.server.command = cliArgs.command;
-  }
-  if (cliArgs.restartOnSwitch !== null) {
-    config.server.restartOnSwitch = cliArgs.restartOnSwitch;
-  }
-
-  // Git settings
-  if (cliArgs.remote !== null) {
-    config.remoteName = cliArgs.remote;
-  }
-  if (cliArgs.autoPull !== null) {
-    config.autoPull = cliArgs.autoPull;
-  }
-  if (cliArgs.pollInterval !== null) {
-    config.gitPollInterval = cliArgs.pollInterval;
-  }
-
-  // UI settings
-  if (cliArgs.sound !== null) {
-    config.soundEnabled = cliArgs.sound;
-  }
-  if (cliArgs.visibleBranches !== null) {
-    config.visibleBranches = cliArgs.visibleBranches;
-  }
-
-  return config;
+  return mergeCliArgs(config, cliArgs);
 }
 
-// Parse CLI arguments
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const result = {
-    // Server settings
-    mode: null,
-    noServer: false,
-    port: null,
-    staticDir: null,
-    command: null,
-    restartOnSwitch: null,
-    // Git settings
-    remote: null,
-    autoPull: null,
-    pollInterval: null,
-    // UI settings
-    sound: null,
-    visibleBranches: null,
-    // Actions
-    init: false,
-  };
+// mergeCliArgs imported from src/cli/args.js as mergeCliArgs
 
-  for (let i = 0; i < args.length; i++) {
-    // Server settings
-    if (args[i] === '--mode' || args[i] === '-m') {
-      const mode = args[i + 1];
-      if (['static', 'command', 'none'].includes(mode)) {
-        result.mode = mode;
-      }
-      i++;
-    } else if (args[i] === '--port' || args[i] === '-p') {
-      const portValue = parseInt(args[i + 1], 10);
-      if (!isNaN(portValue) && portValue > 0 && portValue < 65536) {
-        result.port = portValue;
-      }
-      i++;
-    } else if (args[i] === '--no-server' || args[i] === '-n') {
-      result.noServer = true;
-    } else if (args[i] === '--static-dir') {
-      result.staticDir = args[i + 1];
-      i++;
-    } else if (args[i] === '--command' || args[i] === '-c') {
-      result.command = args[i + 1];
-      i++;
-    } else if (args[i] === '--restart-on-switch') {
-      result.restartOnSwitch = true;
-    } else if (args[i] === '--no-restart-on-switch') {
-      result.restartOnSwitch = false;
-    }
-    // Git settings
-    else if (args[i] === '--remote' || args[i] === '-r') {
-      result.remote = args[i + 1];
-      i++;
-    } else if (args[i] === '--auto-pull') {
-      result.autoPull = true;
-    } else if (args[i] === '--no-auto-pull') {
-      result.autoPull = false;
-    } else if (args[i] === '--poll-interval') {
-      const interval = parseInt(args[i + 1], 10);
-      if (!isNaN(interval) && interval > 0) {
-        result.pollInterval = interval;
-      }
-      i++;
-    }
-    // UI settings
-    else if (args[i] === '--sound') {
-      result.sound = true;
-    } else if (args[i] === '--no-sound') {
-      result.sound = false;
-    } else if (args[i] === '--visible-branches') {
-      const count = parseInt(args[i + 1], 10);
-      if (!isNaN(count) && count > 0) {
-        result.visibleBranches = count;
-      }
-      i++;
-    }
-    // Actions and info
-    else if (args[i] === '--init') {
-      result.init = true;
-    } else if (args[i] === '--version' || args[i] === '-v') {
-      console.log(`git-watchtower v${PACKAGE_VERSION}`);
-      process.exit(0);
-    } else if (args[i] === '--help' || args[i] === '-h') {
-      console.log(`
-Git Watchtower v${PACKAGE_VERSION} - Branch Monitor & Dev Server
-
-Usage:
-  git-watchtower [options]
-
-Server Options:
-  -m, --mode <mode>       Server mode: static, command, or none
-  -p, --port <port>       Server port (default: 3000)
-  -n, --no-server         Shorthand for --mode none
-  --static-dir <dir>      Directory for static file serving (default: public)
-  -c, --command <cmd>     Command to run in command mode (e.g., "npm run dev")
-  --restart-on-switch     Restart server on branch switch (default)
-  --no-restart-on-switch  Don't restart server on branch switch
-
-Git Options:
-  -r, --remote <name>     Git remote name (default: origin)
-  --auto-pull             Auto-pull on branch switch (default)
-  --no-auto-pull          Don't auto-pull on branch switch
-  --poll-interval <ms>    Git polling interval in ms (default: 5000)
-
-UI Options:
-  --sound                 Enable sound notifications (default)
-  --no-sound              Disable sound notifications
-  --visible-branches <n>  Number of branches to display (default: 7)
-
-General:
-  --init                  Run the configuration wizard
-  -v, --version           Show version number
-  -h, --help              Show this help message
-
-Server Modes:
-  static   Serve static files with live reload (default)
-  command  Run your own dev server (Next.js, Vite, Nuxt, etc.)
-  none     Branch monitoring only
-
-Configuration:
-  On first run, Git Watchtower will prompt you to configure settings.
-  Settings are saved to .watchtowerrc.json in your project directory.
-  CLI options override config file settings for the current session.
-
-Examples:
-  git-watchtower                              # Start with config or defaults
-  git-watchtower --init                       # Re-run configuration wizard
-  git-watchtower --no-server                  # Branch monitoring only
-  git-watchtower -p 8080                      # Override port
-  git-watchtower -m command -c "npm run dev"  # Use custom dev server
-  git-watchtower --no-sound --poll-interval 10000
-`);
-      process.exit(0);
-    }
-  }
-  return result;
-}
-
-const cliArgs = parseArgs();
+// CLI argument parsing delegated to src/cli/args.js
+const cliArgs = parseCliArgs(process.argv.slice(2), {
+  onVersion: (v) => { console.log(`git-watchtower v${v}`); process.exit(0); },
+  onHelp: (v) => { console.log(getHelpText(v)); process.exit(0); },
+});
 
 // Configuration - these will be set after config is loaded
 let SERVER_MODE = 'static';      // 'static' | 'command' | 'none'
@@ -674,25 +415,190 @@ function clearServerLog() {
   serverLogBuffer = [];
 }
 
-// Open URL in default browser (cross-platform)
+// openInBrowser imported from src/utils/browser.js
 function openInBrowser(url) {
-  const platform = process.platform;
-  let command;
+  openUrl(url, (error) => {
+    addLog(`Failed to open browser: ${error.message}`, 'error');
+  });
+}
 
-  if (platform === 'darwin') {
-    command = `open "${url}"`;
-  } else if (platform === 'win32') {
-    command = `start "" "${url}"`;
-  } else {
-    // Linux and other Unix-like systems
-    command = `xdg-open "${url}"`;
+// parseRemoteUrl, buildBranchUrl, detectPlatform, buildWebUrl, extractSessionUrl
+// imported from src/git/remote.js
+
+async function getRemoteWebUrl(branchName) {
+  try {
+    const { stdout } = await execAsync(`git remote get-url "${REMOTE_NAME}"`);
+    const parsed = parseRemoteUrl(stdout);
+    return buildWebUrl(parsed, branchName);
+  } catch (e) {
+    return null;
   }
+}
 
-  exec(command, (error) => {
-    if (error) {
-      addLog(`Failed to open browser: ${error.message}`, 'error');
+// Extract Claude Code session URL from the most recent commit on a branch
+async function getSessionUrl(branchName) {
+  try {
+    const { stdout } = await execAsync(
+      `git log "${REMOTE_NAME}/${branchName}" -1 --format=%B 2>/dev/null || git log "${branchName}" -1 --format=%B 2>/dev/null`
+    );
+    return extractSessionUrl(stdout);
+  } catch (e) {
+    return null;
+  }
+}
+
+// Check if a CLI tool is available
+async function hasCommand(cmd) {
+  try {
+    await execAsync(`which ${cmd} 2>/dev/null`);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// detectPlatform imported from src/git/remote.js
+
+// Get PR info for a branch using gh or glab CLI (parsing delegated to src/git/pr.js)
+async function getPrInfo(branchName, platform, hasGh, hasGlab) {
+  if (platform === 'github' && hasGh) {
+    try {
+      const { stdout } = await execAsync(
+        `gh pr list --head "${branchName}" --state all --json number,title,state,reviewDecision,statusCheckRollup --limit 1`
+      );
+      return parseGitHubPr(JSON.parse(stdout));
+    } catch (e) { /* gh not authed or other error */ }
+  }
+  if (platform === 'gitlab' && hasGlab) {
+    try {
+      const { stdout } = await execAsync(
+        `glab mr list --source-branch="${branchName}" --state all --output json 2>/dev/null`
+      );
+      return parseGitLabMr(JSON.parse(stdout));
+    } catch (e) { /* glab not authed or other error */ }
+  }
+  return null;
+}
+
+// Check if gh/glab CLI is authenticated
+async function checkCliAuth(cmd) {
+  try {
+    if (cmd === 'gh') {
+      await execAsync('gh auth status 2>&1');
+    } else if (cmd === 'glab') {
+      await execAsync('glab auth status 2>&1');
     }
-  });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Bulk-fetch PR statuses for all branches (parsing delegated to src/git/pr.js)
+async function fetchAllPrStatuses() {
+  if (!cachedEnv) return null;
+  const { platform, hasGh, ghAuthed, hasGlab, glabAuthed } = cachedEnv;
+
+  if (platform === 'github' && hasGh && ghAuthed) {
+    try {
+      const { stdout } = await execAsync(
+        'gh pr list --state all --json headRefName,number,title,state --limit 200'
+      );
+      return parseGitHubPrList(JSON.parse(stdout));
+    } catch (e) { /* gh error */ }
+  }
+
+  if (platform === 'gitlab' && hasGlab && glabAuthed) {
+    try {
+      const { stdout } = await execAsync(
+        'glab mr list --state all --output json 2>/dev/null'
+      );
+      return parseGitLabMrList(JSON.parse(stdout));
+    } catch (e) { /* glab error */ }
+  }
+
+  return null;
+}
+
+// One-time environment detection (called at startup)
+async function initActionCache() {
+  const [hasGh, hasGlab, webUrlBase] = await Promise.all([
+    hasCommand('gh'),
+    hasCommand('glab'),
+    getRemoteWebUrl(null), // base URL without branch
+  ]);
+
+  let ghAuthed = false;
+  let glabAuthed = false;
+  if (hasGh) ghAuthed = await checkCliAuth('gh');
+  if (hasGlab) glabAuthed = await checkCliAuth('glab');
+
+  const platform = detectPlatform(webUrlBase);
+
+  cachedEnv = { hasGh, hasGlab, ghAuthed, glabAuthed, webUrlBase, platform };
+}
+
+// Phase 1: Instant local data for the modal (no network calls)
+function gatherLocalActionData(branch) {
+  const isClaudeBranch = /^claude\//.test(branch.name);
+  const env = cachedEnv || { hasGh: false, hasGlab: false, ghAuthed: false, glabAuthed: false, webUrlBase: null, platform: 'github' };
+
+  // Build branch-specific web URL from cached base
+  let webUrl = null;
+  if (env.webUrlBase) {
+    try {
+      const host = new URL(env.webUrlBase).hostname;
+      webUrl = buildBranchUrl(env.webUrlBase, host, branch.name);
+    } catch (e) { /* invalid URL, will be resolved in async phase */ }
+  }
+
+  // Check PR cache (instant if we've seen this branch+commit before)
+  const cached = prInfoCache.get(branch.name);
+  const prInfo = (cached && cached.commit === branch.commit) ? cached.prInfo : null;
+  const prLoaded = !!(cached && cached.commit === branch.commit);
+
+  return {
+    branch, sessionUrl: null, prInfo, webUrl, isClaudeBranch,
+    ...env,
+    prLoaded, // false means PR info still needs to be fetched
+  };
+}
+
+// Phase 2: Async data that requires network/git calls
+async function loadAsyncActionData(branch, currentData) {
+  const isClaudeBranch = currentData.isClaudeBranch;
+
+  // Ensure env cache is populated (might have been in flight during Phase 1)
+  if (!cachedEnv) {
+    await initActionCache();
+  }
+  const env = cachedEnv || {};
+
+  // Resolve webUrl if it wasn't available synchronously
+  let webUrl = currentData.webUrl;
+  if (!webUrl && env.webUrlBase) {
+    try {
+      const host = new URL(env.webUrlBase).hostname;
+      webUrl = buildBranchUrl(env.webUrlBase, host, branch.name);
+    } catch (e) { /* ignore */ }
+  }
+
+  // Fetch session URL (local git, fast but async)
+  const sessionUrl = isClaudeBranch ? await getSessionUrl(branch.name) : null;
+
+  // Fetch PR info if not cached
+  let prInfo = currentData.prInfo;
+  let prLoaded = currentData.prLoaded;
+  if (!prLoaded) {
+    const canQueryPr = (env.platform === 'github' && env.hasGh && env.ghAuthed) ||
+                       (env.platform === 'gitlab' && env.hasGlab && env.glabAuthed);
+    prInfo = canQueryPr ? await getPrInfo(branch.name, env.platform, env.hasGh && env.ghAuthed, env.hasGlab && env.glabAuthed) : null;
+    // Cache the result, keyed by branch commit
+    prInfoCache.set(branch.name, { commit: branch.commit, prInfo });
+    prLoaded = true;
+  }
+
+  return { ...currentData, ...env, webUrl, sessionUrl, prInfo, prLoaded };
 }
 
 // Command mode server management
@@ -811,94 +717,11 @@ let pollIntervalId = null;
 let isDetachedHead = false;
 let hasMergeConflict = false;
 
-// ANSI escape codes
-const ESC = '\x1b';
-const CSI = `${ESC}[`;
-
-const ansi = {
-  // Screen
-  clearScreen: `${CSI}2J`,
-  clearLine: `${CSI}2K`,
-  moveTo: (row, col) => `${CSI}${row};${col}H`,
-  moveToTop: `${CSI}H`,
-  hideCursor: `${CSI}?25l`,
-  showCursor: `${CSI}?25h`,
-  saveScreen: `${CSI}?1049h`,
-  restoreScreen: `${CSI}?1049l`,
-
-  // Colors
-  reset: `${CSI}0m`,
-  bold: `${CSI}1m`,
-  dim: `${CSI}2m`,
-  italic: `${CSI}3m`,
-  underline: `${CSI}4m`,
-  inverse: `${CSI}7m`,
-  blink: `${CSI}5m`,
-
-  // Foreground colors
-  black: `${CSI}30m`,
-  red: `${CSI}31m`,
-  green: `${CSI}32m`,
-  yellow: `${CSI}33m`,
-  blue: `${CSI}34m`,
-  magenta: `${CSI}35m`,
-  cyan: `${CSI}36m`,
-  white: `${CSI}37m`,
-  gray: `${CSI}90m`,
-
-  // Bright foreground colors
-  brightRed: `${CSI}91m`,
-  brightGreen: `${CSI}92m`,
-  brightYellow: `${CSI}93m`,
-  brightBlue: `${CSI}94m`,
-  brightMagenta: `${CSI}95m`,
-  brightCyan: `${CSI}96m`,
-  brightWhite: `${CSI}97m`,
-
-  // Background colors
-  bgBlack: `${CSI}40m`,
-  bgRed: `${CSI}41m`,
-  bgGreen: `${CSI}42m`,
-  bgYellow: `${CSI}43m`,
-  bgBlue: `${CSI}44m`,
-  bgMagenta: `${CSI}45m`,
-  bgCyan: `${CSI}46m`,
-  bgWhite: `${CSI}47m`,
-
-  // Bright background colors
-  bgBrightRed: `${CSI}101m`,
-  bgBrightGreen: `${CSI}102m`,
-  bgBrightYellow: `${CSI}103m`,
-  bgBrightBlue: `${CSI}104m`,
-  bgBrightMagenta: `${CSI}105m`,
-  bgBrightCyan: `${CSI}106m`,
-  bgBrightWhite: `${CSI}107m`,
-
-  // 256 colors
-  fg256: (n) => `${CSI}38;5;${n}m`,
-  bg256: (n) => `${CSI}48;5;${n}m`,
-};
+// ANSI escape codes and box drawing imported from src/ui/ansi.js
+const { ansi, box, truncate, sparkline: uiSparkline, visibleLength, stripAnsi } = require('../src/ui/ansi');
 
-// Box drawing characters
-const box = {
-  topLeft: '┌',
-  topRight: '┐',
-  bottomLeft: '└',
-  bottomRight: '┘',
-  horizontal: '─',
-  vertical: '│',
-  teeRight: '├',
-  teeLeft: '┤',
-  cross: '┼',
-
-  // Double line for flash
-  dTopLeft: '╔',
-  dTopRight: '╗',
-  dBottomLeft: '╚',
-  dBottomRight: '╝',
-  dHorizontal: '═',
-  dVertical: '║',
-};
+// Error detection utilities imported from src/utils/errors.js
+const { ErrorHandler } = require('../src/utils/errors');
 
 // State
 let branches = [];
@@ -935,6 +758,27 @@ let searchMode = false;
 let searchQuery = '';
 let filteredBranches = null;
 
+// Branch action modal state
+let actionMode = false;
+let actionData = null; // { branch, sessionUrl, prInfo, hasGh, hasGlab, webUrl, isClaudeBranch, ... }
+let actionLoading = false; // true while PR info is being fetched asynchronously
+
+// Cached environment info (populated once at startup, doesn't change during session)
+let cachedEnv = null; // { hasGh, hasGlab, ghAuthed, glabAuthed, webUrlBase, platform }
+
+// Per-branch PR info cache: Map<branchName, { commit, prInfo }>
+// Invalidated when the branch's commit hash changes
+const prInfoCache = new Map();
+
+// Bulk PR status map: Map<branchName, { state: 'OPEN'|'MERGED'|'CLOSED', number, title }>
+// Updated in background every PR_STATUS_POLL_INTERVAL ms
+let branchPrStatusMap = new Map();
+let lastPrStatusFetch = 0;
+const PR_STATUS_POLL_INTERVAL = 60 * 1000; // 60 seconds
+let prStatusFetchInFlight = false;
+
+// BASE_BRANCH_RE and isBaseBranch imported from src/git/pr.js
+
 // Session history for undo
 const switchHistory = [];
 const MAX_HISTORY = 20;
@@ -1020,27 +864,9 @@ async function getDiffStats(fromCommit, toCommit = 'HEAD') {
   }
 }
 
-function formatTimeAgo(date) {
-  const now = new Date();
-  const diffMs = now - date;
-  const diffSec = Math.floor(diffMs / 1000);
-  const diffMin = Math.floor(diffSec / 60);
-  const diffHr = Math.floor(diffMin / 60);
-  const diffDay = Math.floor(diffHr / 24);
+// formatTimeAgo imported from src/utils/time.js
 
-  if (diffSec < 10) return 'just now';
-  if (diffSec < 60) return `${diffSec}s ago`;
-  if (diffMin < 60) return `${diffMin}m ago`;
-  if (diffHr < 24) return `${diffHr}h ago`;
-  if (diffDay === 1) return '1 day ago';
-  return `${diffDay} days ago`;
-}
-
-function truncate(str, maxLen) {
-  if (!str) return '';
-  if (str.length <= maxLen) return str;
-  return str.substring(0, maxLen - 3) + '...';
-}
+// truncate imported from src/ui/ansi.js
 
 function padRight(str, len) {
   if (str.length >= len) return str.substring(0, len);
@@ -1109,16 +935,10 @@ function addLog(message, type = 'info') {
   if (activityLog.length > MAX_LOG_ENTRIES) activityLog.pop();
 }
 
-// Sparkline characters (8 levels)
-const SPARKLINE_CHARS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
-
+// generateSparkline uses uiSparkline from src/ui/ansi.js
 function generateSparkline(commitCounts) {
   if (!commitCounts || commitCounts.length === 0) return '       ';
-  const max = Math.max(...commitCounts, 1);
-  return commitCounts.map(count => {
-    const level = Math.floor((count / max) * 7);
-    return SPARKLINE_CHARS[level];
-  }).join('');
+  return uiSparkline(commitCounts);
 }
 
 async function getBranchSparkline(branchName) {
@@ -1200,30 +1020,10 @@ async function getPreviewData(branchName) {
   }
 }
 
+// playSound delegates to extracted src/utils/sound.js
 function playSound() {
   if (!soundEnabled) return;
-
-  // Try to play a friendly system sound (non-blocking)
-  const { platform } = process;
-
-  if (platform === 'darwin') {
-    // macOS: Use afplay with a gentle system sound
-    // Options: Glass, Pop, Ping, Purr, Submarine, Tink, Blow, Bottle, Frog, Funk, Hero, Morse, Sosumi
-    exec('afplay /System/Library/Sounds/Pop.aiff 2>/dev/null', { cwd: PROJECT_ROOT });
-  } else if (platform === 'linux') {
-    // Linux: Try paplay (PulseAudio) or aplay (ALSA) with a system sound
-    // First try freedesktop sound theme, then fall back to terminal bell
-    exec(
-      'paplay /usr/share/sounds/freedesktop/stereo/message-new-instant.oga 2>/dev/null || ' +
-      'paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null || ' +
-      'aplay /usr/share/sounds/sound-icons/prompt.wav 2>/dev/null || ' +
-      'printf "\\a"',
-      { cwd: PROJECT_ROOT }
-    );
-  } else {
-    // Windows or other: Terminal bell
-    process.stdout.write('\x07');
-  }
+  playSoundEffect({ cwd: PROJECT_ROOT });
 }
 
 // ============================================================================
@@ -1412,6 +1212,11 @@ function renderBranchList() {
     const isCurrent = branch.name === currentBranch;
     const timeAgo = formatTimeAgo(branch.date);
     const sparkline = sparklineCache.get(branch.name) || '       ';
+    const prStatus = branchPrStatusMap.get(branch.name); // { state, number, title } or undefined
+    // Never treat default/base branches as "merged" — they're merge targets, not sources
+    const isBranchBase = isBaseBranch(branch.name);
+    const isMerged = !isBranchBase && prStatus && prStatus.state === 'MERGED';
+    const hasOpenPr = prStatus && prStatus.state === 'OPEN';
 
     // Branch name line
     write(ansi.moveTo(row, 2));
@@ -1433,6 +1238,10 @@ function renderBranchList() {
     if (branch.isDeleted) {
       write(ansi.gray + ansi.dim + displayName + ansi.reset);
       if (isSelected) write(ansi.inverse);
+    } else if (isMerged && !isCurrent) {
+      // Merged branches get dimmed styling (like deleted, but in magenta tint)
+      write(ansi.dim + ansi.fg256(103) + displayName + ansi.reset);
+      if (isSelected) write(ansi.inverse);
     } else if (isCurrent) {
       write(ansi.green + ansi.bold + displayName + ansi.reset);
       if (isSelected) write(ansi.inverse);
@@ -1448,15 +1257,33 @@ function renderBranchList() {
 
     // Sparkline (7 chars)
     if (isSelected) write(ansi.reset);
-    write(ansi.fg256(39) + sparkline + ansi.reset); // Nice blue color
+    if (isMerged && !isCurrent) {
+      write(ansi.dim + ansi.fg256(60) + sparkline + ansi.reset); // Dimmed sparkline for merged
+    } else {
+      write(ansi.fg256(39) + sparkline + ansi.reset); // Nice blue color
+    }
+    if (isSelected) write(ansi.inverse);
+
+    // PR status dot indicator (1 char)
+    if (isSelected) write(ansi.reset);
+    if (isMerged) {
+      write(ansi.dim + ansi.magenta + '●' + ansi.reset);
+    } else if (hasOpenPr) {
+      write(ansi.brightGreen + '●' + ansi.reset);
+    } else {
+      write(' ');
+    }
     if (isSelected) write(ansi.inverse);
-    write(' ');
 
     // Status badge
     if (branch.isDeleted) {
       if (isSelected) write(ansi.reset);
       write(ansi.red + ansi.dim + '✗ DELETED' + ansi.reset);
       if (isSelected) write(ansi.inverse);
+    } else if (isMerged && !isCurrent && !branch.isNew && !branch.hasUpdates) {
+      if (isSelected) write(ansi.reset);
+      write(ansi.dim + ansi.magenta + '✓ MERGED ' + ansi.reset);
+      if (isSelected) write(ansi.inverse);
     } else if (isCurrent) {
       if (isSelected) write(ansi.reset);
       write(ansi.green + '★ CURRENT' + ansi.reset);
@@ -1484,10 +1311,25 @@ function renderBranchList() {
 
     // Commit info line
     write(ansi.moveTo(row, 2));
-    write('      └─ ');
-    write(ansi.cyan + (branch.commit || '???????') + ansi.reset);
-    write(' • ');
-    write(ansi.gray + truncate(branch.subject || 'No commit message', contentWidth - 22) + ansi.reset);
+    if (isMerged && !isCurrent) {
+      // Dimmed commit line for merged branches, with PR number
+      write(ansi.dim + '      └─ ' + ansi.reset);
+      write(ansi.dim + ansi.cyan + (branch.commit || '???????') + ansi.reset);
+      write(ansi.dim + ' • ' + ansi.reset);
+      const prTag = ansi.dim + ansi.magenta + '#' + prStatus.number + ansi.reset + ansi.dim + ' ';
+      write(prTag + ansi.gray + ansi.dim + truncate(branch.subject || 'No commit message', contentWidth - 28) + ansi.reset);
+    } else {
+      write('      └─ ');
+      write(ansi.cyan + (branch.commit || '???????') + ansi.reset);
+      write(' • ');
+      if (hasOpenPr) {
+        // Show PR number inline for open PRs
+        const prTag = ansi.brightGreen + '#' + prStatus.number + ansi.reset + ' ';
+        write(prTag + ansi.gray + truncate(branch.subject || 'No commit message', contentWidth - 28) + ansi.reset);
+      } else {
+        write(ansi.gray + truncate(branch.subject || 'No commit message', contentWidth - 22) + ansi.reset);
+      }
+    }
 
     row++;
   }
@@ -1581,6 +1423,7 @@ function renderFooter() {
   write(ansi.gray + '[Enter]' + ansi.reset + ansi.bgBlack + ' Switch  ');
   write(ansi.gray + '[h]' + ansi.reset + ansi.bgBlack + ' History  ');
   write(ansi.gray + '[i]' + ansi.reset + ansi.bgBlack + ' Info  ');
+  write(ansi.gray + '[b]' + ansi.reset + ansi.bgBlack + ' Actions  ');
 
   // Mode-specific keys
   if (!NO_SERVER) {
@@ -2015,6 +1858,222 @@ function renderInfo() {
   write(ansi.gray + 'Press [i] or [Esc] to close' + ansi.reset);
 }
 
+function renderActionModal() {
+  if (!actionMode || !actionData) return;
+
+  const { branch, sessionUrl, prInfo, hasGh, hasGlab, ghAuthed, glabAuthed, webUrl, isClaudeBranch, platform, prLoaded } = actionData;
+
+  const width = Math.min(64, terminalWidth - 4);
+  const innerW = width - 6;
+
+  const platformLabel = platform === 'gitlab' ? 'GitLab' : platform === 'bitbucket' ? 'Bitbucket' : platform === 'azure' ? 'Azure DevOps' : 'GitHub';
+  const prLabel = platform === 'gitlab' ? 'MR' : 'PR';
+  const cliTool = platform === 'gitlab' ? 'glab' : 'gh';
+  const hasCli = platform === 'gitlab' ? hasGlab : hasGh;
+  const cliAuthed = platform === 'gitlab' ? glabAuthed : ghAuthed;
+  const cliReady = hasCli && cliAuthed;
+  const loading = actionLoading; // PR info still loading
+
+  // Build actions list — ALL actions always shown, grayed out with reasons when unavailable
+  // { key, label, available, reason, loading }
+  const actions = [];
+
+  // Open on web
+  actions.push({
+    key: 'b', label: `Open branch on ${platformLabel}`,
+    available: !!webUrl, reason: !webUrl ? 'Could not parse remote URL' : null,
+  });
+
+  // Claude session — always shown so users know it exists
+  actions.push({
+    key: 'c', label: 'Open Claude Code session',
+    available: !!sessionUrl,
+    reason: !isClaudeBranch ? 'Not a Claude branch' : !sessionUrl && !loading ? 'No session URL in commits' : null,
+    loading: isClaudeBranch && !sessionUrl && loading,
+  });
+
+  // PR: create or view depending on state
+  const prIsMerged = prInfo && (prInfo.state === 'MERGED' || prInfo.state === 'merged');
+  const prIsOpen = prInfo && (prInfo.state === 'OPEN' || prInfo.state === 'open');
+  if (prInfo) {
+    actions.push({ key: 'p', label: `View ${prLabel} #${prInfo.number}`, available: !!webUrl, reason: null });
+  } else {
+    actions.push({
+      key: 'p', label: `Create ${prLabel}`,
+      available: cliReady && prLoaded,
+      reason: !hasCli ? `Requires ${cliTool} CLI` : !cliAuthed ? `Run: ${cliTool} auth login` : null,
+      loading: cliReady && !prLoaded,
+    });
+  }
+
+  // Diff — opens on web, just needs a PR and webUrl
+  actions.push({
+    key: 'd', label: `View ${prLabel} diff on ${platformLabel}`,
+    available: !!prInfo && !!webUrl,
+    reason: !prInfo && prLoaded ? `No ${prLabel}` : !webUrl ? 'Could not parse remote URL' : null,
+    loading: !prLoaded && (cliReady || !!webUrl),
+  });
+
+  // Approve — disabled for merged PRs
+  actions.push({
+    key: 'a', label: `Approve ${prLabel}`,
+    available: !!prInfo && prIsOpen && cliReady,
+    reason: prIsMerged ? `${prLabel} already merged` : !hasCli ? `Requires ${cliTool} CLI` : !cliAuthed ? `Run: ${cliTool} auth login` : !prInfo && prLoaded ? `No open ${prLabel}` : null,
+    loading: cliReady && !prLoaded,
+  });
+
+  // Merge — disabled for already-merged PRs
+  actions.push({
+    key: 'm', label: `Merge ${prLabel} (squash)`,
+    available: !!prInfo && prIsOpen && cliReady,
+    reason: prIsMerged ? `${prLabel} already merged` : !hasCli ? `Requires ${cliTool} CLI` : !cliAuthed ? `Run: ${cliTool} auth login` : !prInfo && prLoaded ? `No open ${prLabel}` : null,
+    loading: cliReady && !prLoaded,
+  });
+
+  // CI
+  actions.push({
+    key: 'i', label: 'Check CI status',
+    available: cliReady && (!!prInfo || platform === 'gitlab'),
+    reason: !hasCli ? `Requires ${cliTool} CLI` : !cliAuthed ? `Run: ${cliTool} auth login` : !prInfo && prLoaded && platform !== 'gitlab' ? `No open ${prLabel}` : null,
+    loading: cliReady && !prLoaded && platform !== 'gitlab',
+  });
+
+  // Calculate height
+  let contentLines = 0;
+  contentLines += 2; // spacing + branch name
+  contentLines += 1; // separator
+  contentLines += actions.length;
+  contentLines += 1; // separator
+
+  // Status info
+  const statusInfoLines = [];
+  if (prInfo) {
+    let prStatus = `${prLabel} #${prInfo.number}: ${truncate(prInfo.title, innerW - 20)}`;
+    const badges = [];
+    if (prIsMerged) badges.push('merged');
+    if (prInfo.approved) badges.push('approved');
+    if (prInfo.checksPass) badges.push('checks pass');
+    if (prInfo.checksFail) badges.push('checks fail');
+    if (badges.length) prStatus += ` [${badges.join(', ')}]`;
+    statusInfoLines.push({ color: prIsMerged ? 'magenta' : 'green', text: prStatus });
+  } else if (loading) {
+    statusInfoLines.push({ color: 'gray', text: `Loading ${prLabel} info...` });
+  } else if (cliReady) {
+    statusInfoLines.push({ color: 'gray', text: `No ${prLabel} for this branch` });
+  }
+
+  if (isClaudeBranch) {
+    if (sessionUrl) {
+      const shortSession = sessionUrl.replace('https://claude.ai/code/', '');
+      statusInfoLines.push({ color: 'magenta', text: `Session: ${truncate(shortSession, innerW - 10)}` });
+    } else if (!loading) {
+      statusInfoLines.push({ color: 'gray', text: 'Claude branch (no session URL in commits)' });
+    }
+  }
+
+  contentLines += statusInfoLines.length;
+
+  // Setup hints
+  const hints = [];
+  if (!hasCli) {
+    if (platform === 'gitlab') {
+      hints.push(`Install glab: https://gitlab.com/gitlab-org/cli`);
+      hints.push(`Then run: glab auth login`);
+    } else {
+      hints.push(`Install gh:   https://cli.github.com`);
+      hints.push(`Then run: gh auth login`);
+    }
+  } else if (!cliAuthed) {
+    hints.push(`${cliTool} is installed but not authenticated`);
+    hints.push(`Run: ${cliTool} auth login`);
+  }
+
+  if (hints.length > 0) {
+    contentLines += 1;
+    contentLines += hints.length;
+  }
+
+  contentLines += 2; // blank + close instructions
+
+  const height = contentLines + 3;
+  const col = Math.floor((terminalWidth - width) / 2);
+  const row = Math.floor((terminalHeight - height) / 2);
+
+  // Draw box
+  const borderColor = ansi.brightCyan;
+  write(ansi.moveTo(row, col));
+  write(borderColor + ansi.bold);
+  write(box.dTopLeft + box.dHorizontal.repeat(width - 2) + box.dTopRight);
+
+  for (let i = 1; i < height - 1; i++) {
+    write(ansi.moveTo(row + i, col));
+    write(borderColor + box.dVertical + ansi.reset + ' '.repeat(width - 2) + borderColor + box.dVertical + ansi.reset);
+  }
+
+  write(ansi.moveTo(row + height - 1, col));
+  write(borderColor + box.dBottomLeft + box.dHorizontal.repeat(width - 2) + box.dBottomRight);
+  write(ansi.reset);
+
+  // Title
+  const title = ' Branch Actions ';
+  write(ansi.moveTo(row, col + 2));
+  write(borderColor + ansi.bold + title + ansi.reset);
+
+  let r = row + 2;
+
+  // Branch name with type indicator
+  write(ansi.moveTo(r, col + 3));
+  write(ansi.white + ansi.bold + truncate(branch.name, innerW - 10) + ansi.reset);
+  if (isClaudeBranch) {
+    write(ansi.magenta + ' [Claude]' + ansi.reset);
+  }
+  r++;
+
+  // Separator
+  r++;
+
+  // Actions list — all always visible
+  for (const action of actions) {
+    write(ansi.moveTo(r, col + 3));
+    if (action.loading) {
+      write(ansi.gray + '[' + action.key + '] ' + action.label + '  ' + ansi.dim + ansi.cyan + 'loading...' + ansi.reset);
+    } else if (action.available) {
+      write(ansi.brightCyan + '[' + action.key + ']' + ansi.reset + ' ' + action.label);
+    } else {
+      write(ansi.gray + '[' + action.key + '] ' + action.label);
+      if (action.reason) {
+        write('  ' + ansi.dim + ansi.yellow + action.reason + ansi.reset);
+      }
+      write(ansi.reset);
+    }
+    r++;
+  }
+
+  // Separator
+  r++;
+
+  // Status info
+  for (const info of statusInfoLines) {
+    write(ansi.moveTo(r, col + 3));
+    write(ansi[info.color] + truncate(info.text, innerW) + ansi.reset);
+    r++;
+  }
+
+  // Setup hints
+  if (hints.length > 0) {
+    r++;
+    for (const hint of hints) {
+      write(ansi.moveTo(r, col + 3));
+      write(ansi.yellow + truncate(hint, innerW) + ansi.reset);
+      r++;
+    }
+  }
+
+  // Close instructions
+  write(ansi.moveTo(row + height - 2, col + Math.floor((width - 18) / 2)));
+  write(ansi.gray + 'Press [Esc] to close' + ansi.reset);
+}
+
 function render() {
   updateTerminalSize();
 
@@ -2120,6 +2179,10 @@ function render() {
     renderLogView();
   }
 
+  if (actionMode) {
+    renderActionModal();
+  }
+
   // Error toast renders on top of everything for maximum visibility
   if (errorToast) {
     renderErrorToast();
@@ -2640,10 +2703,16 @@ async function pollGitChanges() {
     // Remember which branch was selected before updating the list
     const previouslySelectedName = selectedBranchName || (branches[selectedIndex] ? branches[selectedIndex].name : null);
 
-    // Sort: new branches first, then by date, deleted branches at the bottom
+    // Sort: new branches first, then by date, merged branches near bottom, deleted at bottom
     filteredBranches.sort((a, b) => {
+      const aIsBase = isBaseBranch(a.name);
+      const bIsBase = isBaseBranch(b.name);
+      const aMerged = !aIsBase && branchPrStatusMap.has(a.name) && branchPrStatusMap.get(a.name).state === 'MERGED';
+      const bMerged = !bIsBase && branchPrStatusMap.has(b.name) && branchPrStatusMap.get(b.name).state === 'MERGED';
       if (a.isDeleted && !b.isDeleted) return 1;
       if (!a.isDeleted && b.isDeleted) return -1;
+      if (aMerged && !bMerged && !b.isDeleted) return 1;
+      if (!aMerged && bMerged && !a.isDeleted) return -1;
       if (a.isNew && !b.isNew) return -1;
       if (!a.isNew && b.isNew) return 1;
       return b.date - a.date;
@@ -2668,6 +2737,22 @@ async function pollGitChanges() {
       selectedBranchName = branches[selectedIndex] ? branches[selectedIndex].name : null;
     }
 
+    // Background PR status fetch (throttled to every PR_STATUS_POLL_INTERVAL)
+    const now2 = Date.now();
+    if (!prStatusFetchInFlight && cachedEnv && (now2 - lastPrStatusFetch > PR_STATUS_POLL_INTERVAL)) {
+      prStatusFetchInFlight = true;
+      fetchAllPrStatuses().then(map => {
+        if (map) {
+          branchPrStatusMap = map;
+          render(); // re-render to show updated PR indicators
+        }
+        lastPrStatusFetch = Date.now();
+        prStatusFetchInFlight = false;
+      }).catch(() => {
+        prStatusFetchInFlight = false;
+      });
+    }
+
     // AUTO-PULL: If current branch has remote updates, pull automatically (if enabled)
     const currentInfo = branches.find(b => b.name === currentBranch);
     if (AUTO_PULL && currentInfo && currentInfo.hasUpdates && !hasMergeConflict) {
@@ -3050,6 +3135,166 @@ function setupKeyboardInput() {
       return; // Ignore other keys in log view mode
     }
 
+    if (actionMode) {
+      if (key === '\u001b') { // Escape to close
+        actionMode = false;
+        actionData = null;
+        actionLoading = false;
+        render();
+        return;
+      }
+      if (!actionData) return;
+      const { branch: aBranch, sessionUrl, prInfo, hasGh, hasGlab, ghAuthed, glabAuthed, webUrl, platform, prLoaded } = actionData;
+      const cliReady = (platform === 'gitlab') ? (hasGlab && glabAuthed) : (hasGh && ghAuthed);
+      const prLabel = platform === 'gitlab' ? 'MR' : 'PR';
+
+      // Helper to extract the base repo URL from a branch-specific URL
+      const repoUrl = webUrl ? webUrl.replace(/\/tree\/.*$/, '') : null;
+
+      if (key === 'b' && webUrl) { // Open branch on web host
+        addLog(`Opening ${webUrl}`, 'info');
+        openInBrowser(webUrl);
+        render();
+        return;
+      }
+      if (key === 'c' && sessionUrl) { // Open Claude session
+        addLog(`Opening Claude session...`, 'info');
+        openInBrowser(sessionUrl);
+        render();
+        return;
+      }
+      if (key === 'p') { // Create or view PR
+        if (prInfo && repoUrl) {
+          // View existing PR on web
+          const prUrl = platform === 'gitlab'
+            ? `${repoUrl}/-/merge_requests/${prInfo.number}`
+            : `${repoUrl}/pull/${prInfo.number}`;
+          addLog(`Opening ${prLabel} #${prInfo.number}...`, 'info');
+          openInBrowser(prUrl);
+        } else if (!prInfo && prLoaded && cliReady) {
+          // Create PR — only if we've confirmed no PR exists (prLoaded=true)
+          addLog(`Creating ${prLabel} for ${aBranch.name}...`, 'update');
+          render();
+          try {
+            let result;
+            if (platform === 'gitlab') {
+              result = await execAsync(`glab mr create --source-branch="${aBranch.name}" --fill --yes 2>&1`);
+            } else {
+              result = await execAsync(`gh pr create --head "${aBranch.name}" --fill 2>&1`);
+            }
+            addLog(`${prLabel} created: ${(result.stdout || '').trim().split('\n').pop()}`, 'success');
+            // Invalidate cache and refresh modal data
+            prInfoCache.delete(aBranch.name);
+            actionData = gatherLocalActionData(aBranch);
+            actionLoading = true;
+            render();
+            loadAsyncActionData(aBranch, actionData).then((fullData) => {
+              if (actionMode && actionData && actionData.branch.name === aBranch.name) {
+                actionData = fullData;
+                actionLoading = false;
+                render();
+              }
+            }).catch(() => {});
+          } catch (e) {
+            const msg = (e && e.stderr) || (e && e.message) || String(e);
+            addLog(`Failed to create ${prLabel}: ${msg.split('\n')[0]}`, 'error');
+          }
+        } else if (!prLoaded) {
+          addLog(`Still loading ${prLabel} info...`, 'info');
+        }
+        render();
+        return;
+      }
+      if (key === 'd' && prInfo && repoUrl) { // View diff on web
+        const diffUrl = platform === 'gitlab'
+          ? `${repoUrl}/-/merge_requests/${prInfo.number}/diffs`
+          : `${repoUrl}/pull/${prInfo.number}/files`;
+        addLog(`Opening ${prLabel} #${prInfo.number} diff...`, 'info');
+        openInBrowser(diffUrl);
+        render();
+        return;
+      }
+      if (key === 'a' && prInfo && cliReady) { // Approve PR
+        addLog(`Approving ${prLabel} #${prInfo.number}...`, 'update');
+        render();
+        try {
+          if (platform === 'gitlab') {
+            await execAsync(`glab mr approve ${prInfo.number} 2>&1`);
+          } else {
+            await execAsync(`gh pr review ${prInfo.number} --approve 2>&1`);
+          }
+          addLog(`${prLabel} #${prInfo.number} approved`, 'success');
+          // Refresh PR info to show updated status
+          prInfoCache.delete(aBranch.name);
+        } catch (e) {
+          const msg = (e && e.stderr) || (e && e.message) || String(e);
+          addLog(`Failed to approve: ${msg.split('\n')[0]}`, 'error');
+        }
+        render();
+        return;
+      }
+      if (key === 'm' && prInfo && cliReady) { // Merge PR
+        addLog(`Merging ${prLabel} #${prInfo.number}...`, 'update');
+        render();
+        try {
+          if (platform === 'gitlab') {
+            await execAsync(`glab mr merge ${prInfo.number} --squash --remove-source-branch --yes 2>&1`);
+          } else {
+            await execAsync(`gh pr merge ${prInfo.number} --squash --delete-branch 2>&1`);
+          }
+          addLog(`${prLabel} #${prInfo.number} merged`, 'success');
+          actionMode = false;
+          actionData = null;
+          actionLoading = false;
+          prInfoCache.delete(aBranch.name);
+          // Force-refresh bulk PR statuses so inline indicators update immediately
+          lastPrStatusFetch = 0;
+          await pollGitChanges();
+        } catch (e) {
+          const msg = (e && e.stderr) || (e && e.message) || String(e);
+          addLog(`Failed to merge: ${msg.split('\n')[0]}`, 'error');
+        }
+        render();
+        return;
+      }
+      if (key === 'i' && cliReady) { // CI status
+        addLog(`Checking CI for ${aBranch.name}...`, 'info');
+        render();
+        try {
+          if (platform === 'gitlab') {
+            const result = await execAsync(`glab ci status --branch "${aBranch.name}" 2>&1`);
+            const lines = (result.stdout || '').trim().split('\n');
+            for (const line of lines.slice(0, 3)) {
+              addLog(line.trim(), 'info');
+            }
+          } else if (prInfo) {
+            const result = await execAsync(`gh pr checks ${prInfo.number} 2>&1`);
+            const lines = (result.stdout || '').trim().split('\n');
+            for (const line of lines.slice(0, 5)) {
+              addLog(line.trim(), 'info');
+            }
+          } else {
+            addLog(`No open ${prLabel} — CI status requires an open ${prLabel} on GitHub`, 'info');
+          }
+        } catch (e) {
+          // gh pr checks exits non-zero when checks fail — stdout still has useful info
+          const output = (e && e.stdout) || '';
+          if (output.trim()) {
+            const lines = output.trim().split('\n');
+            for (const line of lines.slice(0, 5)) {
+              addLog(line.trim(), 'info');
+            }
+          } else {
+            const msg = (e && e.stderr) || (e && e.message) || String(e);
+            addLog(`CI check failed: ${msg.split('\n')[0]}`, 'error');
+          }
+        }
+        render();
+        return;
+      }
+      return; // Ignore other keys in action mode
+    }
+
     // Dismiss flash on any key
     if (flashMessage) {
       hideFlash();
@@ -3175,6 +3420,34 @@ function setupKeyboardInput() {
         }
         break;
 
+      case 'b': { // Branch action modal
+        const branch = displayBranches.length > 0 && selectedIndex < displayBranches.length
+          ? displayBranches[selectedIndex] : null;
+        if (branch) {
+          // Phase 1: Open modal instantly with local/cached data
+          actionData = gatherLocalActionData(branch);
+          actionMode = true;
+          actionLoading = !actionData.prLoaded;
+          render();
+
+          // Phase 2: Load async data (session URL, PR info) in background
+          loadAsyncActionData(branch, actionData).then((fullData) => {
+            // Only update if modal is still open for the same branch
+            if (actionMode && actionData && actionData.branch.name === branch.name) {
+              actionData = fullData;
+              actionLoading = false;
+              render();
+            }
+          }).catch(() => {
+            if (actionMode && actionData && actionData.branch.name === branch.name) {
+              actionLoading = false;
+              render();
+            }
+          });
+        }
+        break;
+      }
+
       case 'f':
         addLog('Fetching all branches...', 'update');
         await pollGitChanges();
@@ -3371,8 +3644,18 @@ async function start() {
     selectedBranchName = branches[0].name;
   }
 
-  // Load sparklines in background
+  // Load sparklines and action cache in background
   refreshAllSparklines().catch(() => {});
+  initActionCache().then(() => {
+    // Once env is known, kick off initial PR status fetch
+    fetchAllPrStatuses().then(map => {
+      if (map) {
+        branchPrStatusMap = map;
+        lastPrStatusFetch = Date.now();
+        render();
+      }
+    }).catch(() => {});
+  }).catch(() => {});
 
   // Start server based on mode
   if (SERVER_MODE === 'none') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {