git-watchtower 1.8.6 → 1.9.0

package/bin/git-watchtower.js

@@ -66,7 +66,7 @@ const casinoSounds = require('../src/casino/sounds');
 // Gitignore utilities for file watcher
 const { loadGitignorePatterns, shouldIgnoreFile } = require('../src/utils/gitignore');
 
-// Telemetry (opt-in PostHog analytics)
+// Telemetry (opt-in analytics via PostHog HTTP API — zero dependencies)
 const telemetry = require('../src/telemetry');
 
 // Extracted modules
@@ -82,7 +82,10 @@ const { parseGitHubPr, parseGitLabMr, parseGitHubPrList, parseGitLabMrList, isBa
 // Security & Validation (imported from src/git/branch.js and src/git/commands.js)
 // ============================================================================
 const { isValidBranchName, sanitizeBranchName, getGoneBranches, deleteGoneBranches } = require('../src/git/branch');
-const { isGitAvailable: checkGitAvailable, execGit, execGitSilent, getDiffStats: getDiffStatsSafe } = require('../src/git/commands');
+const { isGitAvailable: checkGitAvailable, execGit, execGitSilent, getDiffStats: getDiffStatsSafe, getAheadBehind, getDiffShortstat } = require('../src/git/commands');
+
+// Session stats (always-on, non-casino stats)
+const sessionStats = require('../src/stats/session');
 
 // ============================================================================
 // Configuration (imports from src/config/, inline wizard kept here)
@@ -858,6 +861,53 @@ async function getDiffStats(fromCommit, toCommit = 'HEAD') {
   return getDiffStatsSafe(fromCommit, toCommit, { cwd: PROJECT_ROOT });
 }
 
+// Ahead/behind: detect default branch and fetch counts
+let detectedDefaultBranch = null;
+
+async function detectDefaultBranch() {
+  const candidates = ['main', 'master', 'develop', 'development', 'trunk'];
+  for (const name of candidates) {
+    try {
+      await execGit(['rev-parse', '--verify', `${REMOTE_NAME}/${name}`], { cwd: PROJECT_ROOT });
+      detectedDefaultBranch = `${REMOTE_NAME}/${name}`;
+      return;
+    } catch (e) {
+      // Try next candidate
+    }
+  }
+  // Fallback: try HEAD of remote
+  try {
+    const { stdout } = await execGit(['symbolic-ref', `refs/remotes/${REMOTE_NAME}/HEAD`], { cwd: PROJECT_ROOT });
+    detectedDefaultBranch = stdout.trim().replace('refs/remotes/', '');
+  } catch (e) {
+    detectedDefaultBranch = null;
+  }
+}
+
+async function fetchAheadBehindForBranches(branches) {
+  if (!detectedDefaultBranch) return;
+  const visible = branches.slice(0, store.get('visibleBranchCount'));
+  const cache = new Map(store.get('aheadBehindCache'));
+  const promises = visible.map(async (branch) => {
+    if (isBaseBranch(branch.name)) return;
+    // Use local ref if local, otherwise remote ref
+    const branchRef = branch.isLocal ? branch.name : `${REMOTE_NAME}/${branch.name}`;
+    const [abResult, diffResult] = await Promise.all([
+      getAheadBehind(branchRef, detectedDefaultBranch, { cwd: PROJECT_ROOT }),
+      getDiffShortstat(detectedDefaultBranch, branchRef, { cwd: PROJECT_ROOT }),
+    ]);
+    cache.set(branch.name, {
+      ahead: abResult.ahead,
+      behind: abResult.behind,
+      linesAdded: diffResult.added,
+      linesDeleted: diffResult.deleted,
+    });
+  });
+  await Promise.all(promises);
+  store.setState({ aheadBehindCache: cache });
+  render();
+}
+
 // formatTimeAgo imported from src/utils/time.js
 
 // truncate imported from src/ui/ansi.js
@@ -1118,6 +1168,7 @@ function renderCasinoStats(startRow) {
 function getRenderState() {
   const s = store.getState();
   s.clientCount = clients.size;
+  s.sessionStats = sessionStats.getStats();
   return s;
 }
 
@@ -1141,7 +1192,8 @@ function render() {
   renderer.renderHeader(state, write);
   const logStart = renderer.renderBranchList(state, write);
   const statsStart = renderer.renderActivityLog(state, write, logStart);
-  renderCasinoStats(statsStart);
+  const casinoStart = renderer.renderSessionStats(state, write, statsStart);
+  renderCasinoStats(casinoStart);
   renderer.renderFooter(state, write);
 
   // Casino mode: full border (top, bottom, left, right)
@@ -1819,6 +1871,9 @@ async function pollGitChanges() {
       casino.recordPoll(false);
     }
 
+    // Session stats: always track polls (independent of casino mode)
+    sessionStats.recordPoll(notifyBranches.length > 0);
+
     // Remember which branch was selected before updating the list
     const { selectedBranchName: prevSelName, selectedIndex: prevSelIdx } = store.getState();
     const previouslySelectedName = prevSelName || (currentBranches[prevSelIdx] ? currentBranches[prevSelIdx].name : null);
@@ -1875,6 +1930,9 @@ async function pollGitChanges() {
       });
     }
 
+    // Background ahead/behind fetch for visible branches
+    fetchAheadBehindForBranches(pollFilteredBranches).catch(() => {});
+
     // AUTO-PULL: If current branch has remote updates, pull automatically (if enabled)
     const autoPullBranchName = store.get('currentBranch');
     const currentInfo = store.get('branches').find(b => b.name === autoPullBranchName);
@@ -1897,11 +1955,14 @@ async function pollGitChanges() {
         // Reload browsers
         notifyClients();
 
-        // Casino mode: calculate actual diff and trigger win effect
-        if (store.get('casinoModeEnabled') && oldCommit) {
+        // Calculate actual diff for stats tracking
+        if (oldCommit) {
           const diffStats = await getDiffStats(oldCommit, 'HEAD');
           const totalLines = diffStats.added + diffStats.deleted;
-          if (totalLines > 0) {
+          // Always track session churn
+          sessionStats.recordChurn(diffStats.added, diffStats.deleted);
+          // Casino mode: trigger win effect
+          if (store.get('casinoModeEnabled') && totalLines > 0) {
             casino.triggerWin(diffStats.added, diffStats.deleted, render);
             const winLevel = casino.getWinLevel(totalLines);
             if (winLevel) {
@@ -2975,6 +3036,11 @@ async function start() {
     store.setState({ selectedBranchName: initBranches[0].name });
   }
 
+  // Detect default branch for ahead/behind counts, then fetch initial data
+  detectDefaultBranch().then(() => {
+    fetchAheadBehindForBranches(initBranches).catch(() => {});
+  }).catch(() => {});
+
   // Load sparklines and action cache in background
   refreshAllSparklines().catch(() => {});
   initActionCache().then(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.8.6",
+  "version": "1.9.0",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {
@@ -87,8 +87,5 @@
         }
       ]
     ]
-  },
-  "dependencies": {
-    "posthog-node": "^5.28.0"
   }
 }

package/src/git/commands.js

@@ -13,6 +13,9 @@ const DEFAULT_TIMEOUT = 30000;
 // Longer timeout for fetch operations (60 seconds)
 const FETCH_TIMEOUT = 60000;
 
+// Short timeout for quick local operations (5 seconds)
+const SHORT_TIMEOUT = 5000;
+
 /**
  * Execute a git command safely using execFile (no shell).
  * @param {string | string[]} args - Git arguments as an array (e.g. ['log', '--oneline'])
@@ -393,6 +396,51 @@ async function deleteLocalBranch(branchName, options = {}) {
   }
 }
 
+/**
+ * Get ahead/behind counts for a branch relative to a base ref.
+ * Uses `git rev-list --left-right --count base...branch`.
+ * @param {string} branchRef - Branch ref (e.g. "feature/foo" or "origin/feature/foo")
+ * @param {string} baseRef - Base ref to compare against (e.g. "origin/main")
+ * @param {Object} [options] - Options
+ * @param {string} [options.cwd] - Working directory
+ * @returns {Promise<{ahead: number, behind: number}>}
+ */
+async function getAheadBehind(branchRef, baseRef, options = {}) {
+  try {
+    const { stdout } = await execGit(
+      ['rev-list', '--left-right', '--count', `${baseRef}...${branchRef}`],
+      { ...options, timeout: SHORT_TIMEOUT }
+    );
+    const parts = stdout.trim().split(/\s+/);
+    return {
+      behind: parseInt(parts[0], 10) || 0,
+      ahead: parseInt(parts[1], 10) || 0,
+    };
+  } catch (e) {
+    return { ahead: 0, behind: 0 };
+  }
+}
+
+/**
+ * Get diff stats (lines added/deleted) between two refs using three-dot syntax.
+ * @param {string} baseRef - Base ref (e.g. "origin/main")
+ * @param {string} branchRef - Branch ref (e.g. "feature/foo")
+ * @param {Object} [options] - Options
+ * @param {string} [options.cwd] - Working directory
+ * @returns {Promise<{added: number, deleted: number}>}
+ */
+async function getDiffShortstat(baseRef, branchRef, options = {}) {
+  try {
+    const { stdout } = await execGit(
+      ['diff', '--shortstat', `${baseRef}...${branchRef}`],
+      { ...options, timeout: SHORT_TIMEOUT }
+    );
+    return parseDiffStats(stdout);
+  } catch (e) {
+    return { added: 0, deleted: 0 };
+  }
+}
+
 module.exports = {
   execGit,
   execGitSilent,
@@ -411,6 +459,8 @@ module.exports = {
   parseDiffStats,
   getDiffStats,
   deleteLocalBranch,
+  getAheadBehind,
+  getDiffShortstat,
   DEFAULT_TIMEOUT,
   FETCH_TIMEOUT,
 };

package/src/state/store.js

@@ -95,6 +95,7 @@
  * @property {boolean} casinoModeEnabled - Casino mode enabled
  * @property {Map<string, string>} sparklineCache - Branch sparkline cache
  * @property {Map<string, Object>} branchPrStatusMap - Branch PR status cache
+ * @property {Map<string, Object>} aheadBehindCache - Branch ahead/behind cache
  * @property {string} serverMode - Server mode ('static' | 'command' | 'none')
  * @property {boolean} noServer - No server mode
  * @property {number} port - Server port
@@ -176,6 +177,7 @@ function getInitialState() {
     // Caches (Maps — shallow-copied by getState())
     sparklineCache: new Map(),
     branchPrStatusMap: new Map(),
+    aheadBehindCache: new Map(),
 
     // Config (set once at startup, treated as read-only after)
     serverMode: 'static',

package/src/stats/session.js

@@ -0,0 +1,109 @@
+/**
+ * Session statistics tracker for Git Watchtower.
+ *
+ * Tracks real, grounded stats about repository activity during the current
+ * session — independent of casino mode. These stats are always available
+ * in normal mode.
+ *
+ * @module stats/session
+ */
+
+// ============================================================================
+// Internal state
+// ============================================================================
+
+let sessionStart = Date.now();
+let totalLinesAdded = 0;
+let totalLinesDeleted = 0;
+let totalPolls = 0;
+let pollsWithUpdates = 0;
+let lastUpdateTime = null;
+
+// ============================================================================
+// Recording
+// ============================================================================
+
+/**
+ * Record that a poll cycle completed.
+ * @param {boolean} hadUpdates - Whether any branch had updates
+ */
+function recordPoll(hadUpdates) {
+  totalPolls++;
+  if (hadUpdates) {
+    pollsWithUpdates++;
+    lastUpdateTime = Date.now();
+  }
+}
+
+/**
+ * Record line changes from a detected update.
+ * @param {number} added - Lines added
+ * @param {number} deleted - Lines deleted
+ */
+function recordChurn(added, deleted) {
+  totalLinesAdded += added;
+  totalLinesDeleted += deleted;
+}
+
+// ============================================================================
+// Queries
+// ============================================================================
+
+/**
+ * Format a duration in ms to a human-readable string.
+ * @param {number} ms
+ * @returns {string}
+ */
+function formatDuration(ms) {
+  const hours = Math.floor(ms / 3600000);
+  const minutes = Math.floor((ms % 3600000) / 60000);
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+/**
+ * Get current session stats snapshot.
+ * @returns {{sessionDuration: string, linesAdded: number, linesDeleted: number, totalPolls: number, pollsWithUpdates: number, hitRate: number, lastUpdate: string|null}}
+ */
+function getStats() {
+  const elapsed = Date.now() - sessionStart;
+
+  const hitRate = totalPolls > 0
+    ? Math.round((pollsWithUpdates / totalPolls) * 100)
+    : 0;
+
+  let lastUpdate = null;
+  if (lastUpdateTime) {
+    const sinceUpdate = Date.now() - lastUpdateTime;
+    lastUpdate = formatDuration(sinceUpdate) + ' ago';
+  }
+
+  return {
+    sessionDuration: formatDuration(elapsed),
+    linesAdded: totalLinesAdded,
+    linesDeleted: totalLinesDeleted,
+    totalPolls,
+    pollsWithUpdates,
+    hitRate,
+    lastUpdate,
+  };
+}
+
+/**
+ * Reset all session stats (e.g. for testing).
+ */
+function reset() {
+  sessionStart = Date.now();
+  totalLinesAdded = 0;
+  totalLinesDeleted = 0;
+  totalPolls = 0;
+  pollsWithUpdates = 0;
+  lastUpdateTime = null;
+}
+
+module.exports = {
+  recordPoll,
+  recordChurn,
+  getStats,
+  reset,
+};

package/src/telemetry/analytics.js

@@ -1,23 +1,88 @@
 /**
- * PostHog analytics wrapper (singleton)
+ * Analytics wrapper using direct PostHog HTTP API (zero dependencies)
  *
  * All methods are safe no-ops when telemetry is disabled.
  * Events are fire-and-forget — never blocks the TUI.
  */
 
+const https = require('https');
 const { isTelemetryEnabled, getOrCreateDistinctId } = require('./config');
 
 const POSTHOG_API_KEY = 'phc_fdGL8TVN5aFPXmQ4f1hI8y6sqnscD7dy9j5SM5gTylG';
-const POSTHOG_HOST = 'https://us.i.posthog.com';
+const POSTHOG_HOST = 'us.i.posthog.com';
 
-/** @type {import('posthog-node').PostHog | null} */
-let client = null;
 let distinctId = '';
 let appVersion = '';
 let enabled = false;
 
+/** @type {Array<Record<string, any>>} */
+let eventQueue = [];
+let flushTimer = null;
+const FLUSH_INTERVAL = 30000; // 30 seconds
+const FLUSH_AT = 10; // flush when 10 events accumulated
+
+/**
+ * Send a batch of events to PostHog via HTTPS POST (fire-and-forget)
+ * @param {Array<Record<string, any>>} events
+ */
+function sendBatch(events) {
+  if (events.length === 0) return;
+
+  const payload = JSON.stringify({ api_key: POSTHOG_API_KEY, batch: events });
+
+  const req = https.request({
+    hostname: POSTHOG_HOST,
+    port: 443,
+    path: '/batch',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload),
+    },
+    timeout: 5000,
+  });
+
+  // Fire-and-forget: ignore all errors and responses
+  req.on('error', () => {});
+  req.on('timeout', () => req.destroy());
+  req.end(payload);
+}
+
+/**
+ * Flush pending events
+ */
+function flush() {
+  if (eventQueue.length === 0) return;
+  const batch = eventQueue;
+  eventQueue = [];
+  sendBatch(batch);
+}
+
+/**
+ * Queue an event for sending
+ * @param {string} event - Event name
+ * @param {Record<string, any>} properties - Event properties
+ * @param {string} [overrideDistinctId] - Override distinct ID (for pre-consent events)
+ */
+function queueEvent(event, properties, overrideDistinctId) {
+  eventQueue.push({
+    event,
+    distinct_id: overrideDistinctId || distinctId,
+    properties: {
+      ...properties,
+      $lib: 'git-watchtower',
+      $lib_version: appVersion,
+    },
+    timestamp: new Date().toISOString(),
+  });
+
+  if (eventQueue.length >= FLUSH_AT) {
+    flush();
+  }
+}
+
 /**
- * Initialize the PostHog client if telemetry is enabled
+ * Initialize the analytics client if telemetry is enabled
  * @param {{ version: string }} options
  */
 function init({ version }) {
@@ -28,22 +93,12 @@ function init({ version }) {
     return;
   }
 
-  try {
-    const { PostHog } = require('posthog-node');
-    distinctId = getOrCreateDistinctId();
-    client = new PostHog(POSTHOG_API_KEY, {
-      host: POSTHOG_HOST,
-      flushAt: 10,
-      flushInterval: 30000,
-      requestTimeout: 5000,
-      disableGeoip: true,
-    });
-    enabled = true;
-  } catch {
-    // If posthog-node fails to load, silently disable telemetry
-    enabled = false;
-    client = null;
-  }
+  distinctId = getOrCreateDistinctId();
+  enabled = true;
+
+  // Periodic flush
+  flushTimer = setInterval(flush, FLUSH_INTERVAL);
+  if (flushTimer.unref) flushTimer.unref(); // Don't keep process alive
 }
 
 /**
@@ -52,18 +107,10 @@ function init({ version }) {
  * @param {Record<string, any>} [properties] - Event properties
  */
 function capture(event, properties = {}) {
-  if (!enabled || !client) return;
+  if (!enabled) return;
 
   try {
-    client.capture({
-      distinctId,
-      event,
-      properties: {
-        ...properties,
-        $lib: 'git-watchtower',
-        $lib_version: appVersion,
-      },
-    });
+    queueEvent(event, properties);
   } catch {
     // Never let telemetry errors affect the app
   }
@@ -74,7 +121,7 @@ function capture(event, properties = {}) {
  * @param {Error} error
  */
 function captureError(error) {
-  if (!enabled || !client) return;
+  if (!enabled) return;
 
   try {
     const errorType = error.constructor?.name || 'Error';
@@ -86,41 +133,80 @@ function captureError(error) {
       $exception_type: errorType,
       $exception_message: errorMessage,
       $exception_source: 'node',
-      $lib: 'git-watchtower',
-      $lib_version: appVersion,
     };
 
-    // Include stack trace — contains only our package's file paths and
-    // line numbers, no user data. Required for PostHog error tracking
-    // to group, deduplicate, and show useful backtraces.
     if (error.stack) {
       properties.$exception_stack_trace_raw = error.stack;
     }
 
-    client.capture({
-      distinctId,
-      event: '$exception',
-      properties,
+    queueEvent('$exception', properties);
+  } catch {
+    // Never let telemetry errors affect the app
+  }
+}
+
+/**
+ * Send a one-off event that bypasses the enabled check.
+ * Used for prompt_shown and analytics_decision events that fire
+ * before the user has made their telemetry choice.
+ * @param {string} event - Event name
+ * @param {string} userDistinctId - The user's distinct ID
+ * @param {Record<string, any>} [properties] - Event properties
+ */
+function captureAlways(event, userDistinctId, properties = {}) {
+  try {
+    const payload = JSON.stringify({
+      api_key: POSTHOG_API_KEY,
+      batch: [{
+        event,
+        distinct_id: userDistinctId,
+        properties: {
+          ...properties,
+          $lib: 'git-watchtower',
+          $lib_version: appVersion,
+        },
+        timestamp: new Date().toISOString(),
+      }],
     });
+
+    const req = https.request({
+      hostname: POSTHOG_HOST,
+      port: 443,
+      path: '/batch',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+      timeout: 5000,
+    });
+
+    req.on('error', () => {});
+    req.on('timeout', () => req.destroy());
+    req.end(payload);
   } catch {
     // Never let telemetry errors affect the app
   }
 }
 
 /**
- * Flush pending events and shutdown the PostHog client
+ * Flush pending events and shutdown
  * Call this before process exit to ensure events are sent.
  * @returns {Promise<void>}
  */
 async function shutdown() {
-  if (!enabled || !client) return;
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+
+  if (!enabled) return;
 
   try {
-    await client.shutdown();
+    flush();
   } catch {
     // Best-effort flush
   } finally {
-    client = null;
     enabled = false;
   }
 }
@@ -137,6 +223,7 @@ module.exports = {
   init,
   capture,
   captureError,
+  captureAlways,
   shutdown,
   isEnabled,
 };

package/src/telemetry/index.js

@@ -58,9 +58,16 @@ async function promptIfNeeded(promptYesNo) {
   console.log('\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518');
   console.log('');
 
+  const distinctId = config.getOrCreateDistinctId();
+
+  // Fire analytics_prompt_shown event — always sent regardless of user's choice
+  analytics.captureAlways('analytics_prompt_shown', distinctId);
+
   const answer = await promptYesNo('Enable anonymous telemetry to help improve Git Watchtower?', false);
 
-  const distinctId = config.getOrCreateDistinctId();
+  // Fire analytics_decision event — always sent so we know opt-in/out rates
+  analytics.captureAlways('analytics_decision', distinctId, { opted_in: answer });
+
   config.saveTelemetryConfig({
     telemetryEnabled: answer,
     distinctId,
@@ -79,6 +86,7 @@ module.exports = {
   init: analytics.init,
   capture: analytics.capture,
   captureError: analytics.captureError,
+  captureAlways: analytics.captureAlways,
   shutdown: analytics.shutdown,
   isEnabled: analytics.isEnabled,
 

package/src/ui/renderer.js

@@ -21,10 +21,28 @@ const {
   visibleLength,
   stripAnsi,
 } = require('../ui/ansi');
-const { formatTimeAgo } = require('../utils/time');
+const { formatTimeAgo, formatTimeCompact } = require('../utils/time');
 const { isBaseBranch } = require('../git/pr');
 const { version: PACKAGE_VERSION } = require('../../package.json');
 
+// ---------------------------------------------------------------------------
+// Compact number formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a number compactly: 0-999 as-is, 1k-9.9k with decimal,
+ * 10k-999k without decimal, 1m+ with decimal.
+ * @param {number} n
+ * @returns {string}
+ */
+function fmtCompact(n) {
+  if (n < 1000) return String(n);
+  if (n < 10000) return (n / 1000).toFixed(1) + 'k';
+  if (n < 1000000) return Math.round(n / 1000) + 'k';
+  if (n < 10000000) return (n / 1000000).toFixed(1) + 'm';
+  return Math.round(n / 1000000) + 'm';
+}
+
 // ---------------------------------------------------------------------------
 // renderHeader
 // ---------------------------------------------------------------------------
@@ -167,16 +185,58 @@ function renderBranchList(state, write) {
     const branch = displayBranches[i];
     const isSelected = i === state.selectedIndex;
     const isCurrent = branch.name === state.currentBranch;
-    const timeAgo = formatTimeAgo(branch.date);
+    const timeAgo = formatTimeCompact(branch.date);
     const sparkline = state.sparklineCache.get(branch.name) || '       ';
     const prStatus = state.branchPrStatusMap.get(branch.name);
     const isBranchBase = isBaseBranch(branch.name);
     const isMerged = !isBranchBase && prStatus && prStatus.state === 'MERGED';
     const hasOpenPr = prStatus && prStatus.state === 'OPEN';
+    const aheadBehind = state.aheadBehindCache ? state.aheadBehindCache.get(branch.name) : null;
+
+    // Diff stats: two right-justified columns, always reserving space for alignment
+    // Col 1: "+N/-N commits" right-justified in 16 chars
+    // Col 2: "+N/-N lines"   right-justified in 14 chars
+    // Total: 16 + 1(gap) + 14 + 1(gap) = 32 chars always reserved
+    const COL_COMMITS = 16;
+    const COL_LINES = 14;
+    const DIFF_TAG_FIXED_LEN = COL_COMMITS + 1 + COL_LINES + 1; // 32 total
+    let diffTag = ' '.repeat(DIFF_TAG_FIXED_LEN); // blank by default for alignment
+    if (!isBranchBase && !branch.isDeleted && aheadBehind) {
+      const a = aheadBehind.ahead;
+      const b = aheadBehind.behind;
+      const la = aheadBehind.linesAdded || 0;
+      const ld = aheadBehind.linesDeleted || 0;
+
+      // Commits: "+N/-N commits", right-justified in COL_COMMITS
+      const aFmt = fmtCompact(a);
+      const bFmt = fmtCompact(b);
+      const commitText = '+' + aFmt + '/-' + bFmt + ' commits';
+      const cPad = ' '.repeat(Math.max(0, COL_COMMITS - commitText.length));
+      const commitColored = cPad +
+        (a > 0 ? ansi.brightCyan : ansi.dim + ansi.gray) + '+' + aFmt + ansi.reset +
+        ansi.gray + '/' + ansi.reset +
+        (b > 0 ? ansi.fg256(209) : ansi.dim + ansi.gray) + '-' + bFmt + ansi.reset +
+        ansi.gray + ' commits' + ansi.reset;
+
+      // Lines: "+N/-N lines", right-justified in COL_LINES
+      const laFmt = fmtCompact(la);
+      const ldFmt = fmtCompact(ld);
+      const linesText = '+' + laFmt + '/-' + ldFmt + ' lines';
+      const lPad = ' '.repeat(Math.max(0, COL_LINES - linesText.length));
+      const linesColored = lPad +
+        (la > 0 ? ansi.green : ansi.dim + ansi.gray) + '+' + laFmt + ansi.reset +
+        ansi.gray + '/' + ansi.reset +
+        (ld > 0 ? ansi.red : ansi.dim + ansi.gray) + '-' + ldFmt + ansi.reset +
+        ansi.gray + ' lines' + ansi.reset;
+
+      diffTag = commitColored + ' ' + linesColored + ' ';
+    }
 
     write(ansi.moveTo(row, 2));
     const cursor = isSelected ? ' \u25B6 ' : '   ';
-    const maxNameLen = contentWidth - 38;
+    // Reserve: cursor(3) + sparkline(7) + PR dot(1) + diffTag(32) + status(9) + gap(1) + time(4) + padding(2)
+    const fixedWidth = 27 + DIFF_TAG_FIXED_LEN;
+    const maxNameLen = contentWidth - fixedWidth;
     const displayName = truncate(branch.name, maxNameLen);
     const namePadding = Math.max(1, maxNameLen - displayName.length + 2);
 
@@ -201,17 +261,18 @@ function renderBranchList(state, write) {
 
     write(' '.repeat(namePadding));
 
-    // Sparkline
+    // Sparkline (inside highlight)
     if (isSelected) write(ansi.reset);
     if (isMerged && !isCurrent) {
       write(ansi.dim + ansi.fg256(60) + sparkline + ansi.reset);
     } else {
       write(ansi.fg256(39) + sparkline + ansi.reset);
     }
-    if (isSelected) write(ansi.inverse);
 
-    // PR status dot
+    // End the selected-row highlight here — everything after is outside
     if (isSelected) write(ansi.reset);
+
+    // PR status dot (just before columns)
     if (isMerged) {
       write(ansi.dim + ansi.magenta + '\u25CF' + ansi.reset);
     } else if (hasOpenPr) {
@@ -219,38 +280,28 @@ function renderBranchList(state, write) {
     } else {
       write(' ');
     }
-    if (isSelected) write(ansi.inverse);
+
+    // Diff stats columns
+    write(diffTag);
 
     // Status badge
     if (branch.isDeleted) {
-      if (isSelected) write(ansi.reset);
       write(ansi.red + ansi.dim + '\u2717 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 + '\u2713 MERGED ' + ansi.reset);
-      if (isSelected) write(ansi.inverse);
     } else if (isCurrent) {
-      if (isSelected) write(ansi.reset);
       write(ansi.green + '\u2605 CURRENT' + ansi.reset);
-      if (isSelected) write(ansi.inverse);
     } else if (branch.isNew) {
-      if (isSelected) write(ansi.reset);
       write(ansi.magenta + '\u2726 NEW    ' + ansi.reset);
-      if (isSelected) write(ansi.inverse);
     } else if (branch.hasUpdates) {
-      if (isSelected) write(ansi.reset);
       write(ansi.yellow + '\u2193 UPDATES' + ansi.reset);
-      if (isSelected) write(ansi.inverse);
     } else {
       write('         ');
     }
 
-    // Time ago
-    write('  ');
-    if (isSelected) write(ansi.reset);
-    write(ansi.gray + padLeft(timeAgo, 10) + ansi.reset);
-    if (isSelected) write(ansi.reset);
+    // Time ago (compact)
+    write(' ');
+    write(ansi.gray + padLeft(timeAgo, 4) + ansi.reset);
 
     row++;
 
@@ -322,6 +373,110 @@ function renderActivityLog(state, write, startRow) {
   return startRow + height;
 }
 
+// ---------------------------------------------------------------------------
+// renderSessionStats
+// ---------------------------------------------------------------------------
+
+/**
+ * Render the session statistics panel (always visible in normal mode).
+ *
+ * @param {object} state
+ * @param {function} write
+ * @param {number} startRow - Row where the box should begin.
+ * @returns {number} The row immediately after the session stats box.
+ */
+function renderSessionStats(state, write, startRow) {
+  if (state.casinoModeEnabled) return startRow;
+
+  const stats = state.sessionStats;
+  if (!stats) return startRow;
+
+  const boxWidth = state.terminalWidth;
+  const contentWidth = boxWidth - 4;
+  const STALE_DAYS = 30;
+  const STALE_WARNING_THRESHOLD = 5;
+
+  // Count active vs stale branches
+  const branches = state.branches || [];
+  const now = Date.now();
+  const staleMs = STALE_DAYS * 24 * 60 * 60 * 1000;
+  let staleBranches = 0;
+  let activeBranches = 0;
+  for (const b of branches) {
+    if (b.date && (now - b.date.getTime()) > staleMs) {
+      staleBranches++;
+    } else {
+      activeBranches++;
+    }
+  }
+
+  const showStaleHint = staleBranches >= STALE_WARNING_THRESHOLD;
+
+  // Build the stats line to measure if it fits in one row
+  // Parts: Duration | Lines | Polls (hits, %) | Last update | Branches: N active, N stale
+  let partsPlain = 'Duration: ' + stats.sessionDuration
+    + '  |  Lines: +' + stats.linesAdded + '/-' + stats.linesDeleted
+    + '  |  Polls: ' + stats.totalPolls;
+  if (stats.pollsWithUpdates > 0) {
+    partsPlain += ' (' + stats.pollsWithUpdates + ' hits, ' + stats.hitRate + '%)';
+  }
+  if (stats.lastUpdate) {
+    partsPlain += '  |  Last update: ' + stats.lastUpdate;
+  }
+  partsPlain += '  |  Branches: ' + activeBranches + ' active';
+  if (staleBranches > 0) {
+    partsPlain += ', ' + staleBranches + ' stale (>' + STALE_DAYS + 'd)';
+  }
+  if (showStaleHint) {
+    partsPlain += '  — press d to clean up';
+  }
+
+  const fitOneLine = partsPlain.length <= contentWidth;
+  const height = fitOneLine ? 4 : 5;
+
+  // Don't draw if not enough space
+  if (startRow + height > state.terminalHeight - 3) return startRow;
+
+  write(drawBox(startRow, 1, boxWidth, height, 'SESSION STATS', ansi.gray));
+
+  // Clear content area
+  for (let i = 1; i < height - 1; i++) {
+    write(ansi.moveTo(startRow + i, 2));
+    write(' '.repeat(boxWidth - 2));
+  }
+
+  // Line 1: duration, lines, polls, last update
+  write(ansi.moveTo(startRow + 1, 3));
+  write(ansi.gray + 'Duration: ' + ansi.reset + ansi.cyan + stats.sessionDuration + ansi.reset);
+  write(ansi.gray + '  |  Lines: ' + ansi.reset);
+  write(ansi.green + '+' + stats.linesAdded + ansi.reset);
+  write(ansi.gray + '/' + ansi.reset);
+  write(ansi.red + '-' + stats.linesDeleted + ansi.reset);
+  write(ansi.gray + '  |  Polls: ' + ansi.reset + stats.totalPolls);
+  if (stats.pollsWithUpdates > 0) {
+    write(ansi.gray + ' (' + ansi.reset + ansi.green + stats.pollsWithUpdates + ' hits' + ansi.reset + ansi.gray + ', ' + stats.hitRate + '%)' + ansi.reset);
+  }
+  if (stats.lastUpdate) {
+    write(ansi.gray + '  |  Last update: ' + ansi.reset + ansi.yellow + stats.lastUpdate + ansi.reset);
+  }
+
+  // Branch counts — same line or next line depending on width
+  const branchRow = fitOneLine ? startRow + 1 : startRow + 2;
+  if (!fitOneLine) {
+    write(ansi.moveTo(branchRow, 3));
+  }
+  write(ansi.gray + '  |  Branches: ' + ansi.reset + ansi.green + activeBranches + ' active' + ansi.reset);
+  if (staleBranches > 0) {
+    write(ansi.gray + ', ' + ansi.reset + ansi.yellow + staleBranches + ' stale' + ansi.reset);
+    write(ansi.gray + ' (>' + STALE_DAYS + 'd)' + ansi.reset);
+  }
+  if (showStaleHint) {
+    write(ansi.gray + '  \u2014 press ' + ansi.reset + ansi.white + 'd' + ansi.reset + ansi.gray + ' to clean up' + ansi.reset);
+  }
+
+  return startRow + height;
+}
+
 // ---------------------------------------------------------------------------
 // renderCasinoStats (stub)
 // ---------------------------------------------------------------------------
@@ -1424,6 +1579,7 @@ module.exports = {
   renderHeader,
   renderBranchList,
   renderActivityLog,
+  renderSessionStats,
   renderCasinoStats,
   renderFooter,
   renderFlash,

package/src/utils/time.js

@@ -24,4 +24,24 @@ function formatTimeAgo(date) {
   return `${diffDay} days ago`;
 }
 
-module.exports = { formatTimeAgo };
+/**
+ * Format a date as a compact relative time string (no "ago").
+ * @param {Date} date - The date to format
+ * @returns {string} Compact time string (e.g., "5m", "2h", "6d")
+ */
+function formatTimeCompact(date) {
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSec = Math.floor(diffMs / 1000);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHr = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHr / 24);
+
+  if (diffSec < 10) return 'now';
+  if (diffSec < 60) return `${diffSec}s`;
+  if (diffMin < 60) return `${diffMin}m`;
+  if (diffHr < 24) return `${diffHr}h`;
+  return `${diffDay}d`;
+}
+
+module.exports = { formatTimeAgo, formatTimeCompact };