@happy-nut/monacori 0.1.21 → 0.1.22

package/dist/viewer.client.js

@@ -19,6 +19,27 @@ if (REVIEW_LAZY) {
   });
 }
 var diffBootDone = false;
+// Rebuild the hunk index from the CURRENT diff DOM. `hunks`/`hunkPeers`/`hunkMeta` are captured once at
+// init; after an in-place watch swap (applyDiffUpdate) the DOM holds new wrappers/rows, so without this
+// hunkTotal()/hunkPathAt() keep reporting the OLD build — F7 and showDiffView then target vanished indices
+// and the diff pane goes blank. Mutates the const arrays in place so existing references stay valid.
+function refreshHunkIndex() {
+  if (REVIEW_LAZY) {
+    hunkMeta.length = 0;
+    Array.prototype.forEach.call(document.querySelectorAll('#diff2html-container .d2h-file-wrapper'), function (w) {
+      var base = parseInt(w.dataset.firstHunk || '0', 10) || 0;
+      var cnt = parseInt(w.dataset.hunkCount || '0', 10) || 0;
+      var p = w.dataset.path || ((w.querySelector('.d2h-file-name') || {}).textContent || '').trim();
+      for (var k = 0; k < cnt; k++) hunkMeta[base + k] = { path: p };
+    });
+  } else {
+    prepareDiff2HtmlHunks(); // (re)tag .hunk/.hunk-peer rows + file ids on the new DOM
+    hunks.length = 0;
+    Array.prototype.push.apply(hunks, document.querySelectorAll('.hunk'));
+    hunkPeers.length = 0;
+    Array.prototype.push.apply(hunkPeers, document.querySelectorAll('.hunk-peer'));
+  }
+}
 function hunkTotal() { return REVIEW_LAZY ? hunkMeta.length : hunks.length; }
 function hunkPathAt(i) { return REVIEW_LAZY ? (hunkMeta[i] ? hunkMeta[i].path : '') : (hunks[i] ? hunks[i].dataset.file : ''); }
 function hunkRowAt(i) {
@@ -256,6 +277,7 @@ const quickOpen = document.getElementById('quick-open');
 const quickInput = document.getElementById('quick-open-input');
 const quickResults = document.getElementById('quick-open-results');
 const quickModeLabel = document.getElementById('quick-open-mode');
+const quickFilterEl = document.getElementById('quick-open-filter');
 let current = -1;
 let checkingForUpdates = false;
 let lastShiftAt = 0;
@@ -263,6 +285,7 @@ let lastShiftSide = 0;
 let quickMode = 'all';
 let quickItems = [];
 let quickActive = 0;
+let recentFilter = ''; // IntelliJ-style speed-search: typed letters narrow the Recent list (no search box)
 let usageItems = []; // find-usages results for the Cmd+B-on-declaration popup
 let usageActive = 0;
 let viewerCursor = null;
@@ -660,14 +683,19 @@ function next(delta) {
   // File boundary: no more change blocks in this file. Forward F7 announces "last change — press F7 again
   // to go to the next file" on the FIRST press (a beat to mark-viewed) and only crosses on the SECOND
   // consecutive press. Already-viewed files (and backward nav) cross immediately — no announcement.
-  if (delta > 0 && diffCursor && isDiffViewVisible() && !isFileViewed(diffCursor.path)) {
+  // The `hunkPathAt(current) === diffCursor.path` guard skips the announcement while a cross is still in
+  // flight: after setActive moves `current` to the next file but BEFORE its (async, lazy-loaded) caret lands,
+  // diffCursor still points at the OLD file — without the guard a quick second F7 re-announced that old
+  // boundary instead of letting the cross finish (the "press F7 twice more, no caret" bug).
+  if (delta > 0 && diffCursor && isDiffViewVisible() && !isFileViewed(diffCursor.path) && hunkPathAt(current) === diffCursor.path) {
     if (pendingFileBoundary !== diffCursor.path) {
       pendingFileBoundary = diffCursor.path;
-      showToast(t('diff.lastHunk'));
+      showCaretHint(t('diff.lastHunk'));
       return;
     }
     pendingFileBoundary = null; // second consecutive press on the same file → fall through and cross
   }
+  hideCaretHint(); // about to cross files — drop the hint NOW (before the async body load) so it can't cover the next file
   // hunk-level nav to the next/prev unviewed file.
   const caretHunk = hunkIndexAtCaret();
   const base = caretHunk >= 0 ? caretHunk : current;
@@ -716,9 +744,22 @@ function openQuickOpen(mode) {
   quickMode = mode;
   quickModeLabel.textContent = mode === 'recent' ? t('quickopen.recent') : mode === 'content' ? t('quickopen.findInFiles') : t('quickopen.searchFiles');
   quickOpen.classList.remove('hidden');
+  // Recent files needs no search box — it's just the latest files. Hide the input and let typed letters
+  // narrow the list (IntelliJ-style speed search); the global keydown routes keys to handleQuickOpenKey.
+  quickOpen.classList.toggle('quick-recent', mode === 'recent');
+  recentFilter = '';
   quickInput.value = '';
+  updateRecentFilterDisplay();
   renderQuickOpenResults();
-  setTimeout(() => quickInput.focus(), 0);
+  if (mode === 'recent') { if (document.activeElement && document.activeElement.blur) document.activeElement.blur(); }
+  else setTimeout(() => quickInput.focus(), 0);
+}
+// Title-row indicator for the Recent speed-search: the typed letters, or a muted "type to filter" hint.
+function updateRecentFilterDisplay() {
+  if (!quickFilterEl) return;
+  if (quickMode !== 'recent') { quickFilterEl.textContent = ''; quickFilterEl.className = 'quick-open-filter'; return; }
+  if (recentFilter) { quickFilterEl.textContent = recentFilter; quickFilterEl.className = 'quick-open-filter has-filter'; }
+  else { quickFilterEl.textContent = t('quickopen.typeToFilter'); quickFilterEl.className = 'quick-open-filter is-hint'; }
 }
 
 function closeQuickOpen() {
@@ -728,6 +769,8 @@ function closeQuickOpen() {
 function handleQuickOpenKey(event) {
   if (event.key === 'Escape') {
     event.preventDefault();
+    // Recent speed-search: first Esc clears the typed filter, a second Esc closes (IntelliJ behavior).
+    if (quickMode === 'recent' && recentFilter) { recentFilter = ''; updateRecentFilterDisplay(); renderQuickOpenResults(); return true; }
     closeQuickOpen();
     return true;
   }
@@ -748,15 +791,31 @@ function handleQuickOpenKey(event) {
     openQuickItem(quickItems[quickActive]);
     return true;
   }
+  // Recent files has no input box: type letters to filter the list, Backspace to delete (speed search).
+  if (quickMode === 'recent') {
+    if (event.key === 'Backspace') {
+      event.preventDefault();
+      if (recentFilter) { recentFilter = recentFilter.slice(0, -1); updateRecentFilterDisplay(); renderQuickOpenResults(); }
+      return true;
+    }
+    if (event.key.length === 1 && !event.metaKey && !event.ctrlKey && !event.altKey) {
+      event.preventDefault();
+      recentFilter += event.key;
+      updateRecentFilterDisplay();
+      renderQuickOpenResults();
+      return true;
+    }
+  }
   return false;
 }
 
 function renderQuickOpenResults() {
   if (!quickResults) return;
-  const query = quickInput?.value.trim().toLowerCase() || '';
-  const candidates = quickMode === 'recent' && query.length === 0 ? recentItems() : allQuickItems();
+  // Recent mode filters its own list by the typed speed-search string; other modes use the search box.
+  const isRecent = quickMode === 'recent';
+  const query = (isRecent ? recentFilter : (quickInput?.value || '')).trim().toLowerCase();
+  const candidates = isRecent ? recentItems() : allQuickItems();
   quickItems = candidates
-    .filter((item) => quickMode !== 'recent' || query.length > 0 || item.recent)
     .filter((item) => {
       if (query.length === 0) return true;
       if (quickMode === 'content') {
@@ -1096,17 +1155,17 @@ document.addEventListener('keydown', (event) => {
   // and +. open the merged views; Cmd/Ctrl+Shift+N toggles the memo. (Match event.code so IME/layout never
   // swallows the combo.) Settings is a true overlay, so these stand down while it is up.
   var settingsUp = (function () { var s = document.getElementById('settings-modal'); return !!(s && !s.classList.contains('hidden')); })();
-  if ((event.metaKey || event.ctrlKey) && event.shiftKey && event.code === 'Quote') {
+  if ((event.metaKey || event.ctrlKey) && event.shiftKey && !event.altKey && event.code === 'Quote') {
     event.preventDefault();
     toggleDockMaximized();
     return;
   }
-  if (!settingsUp && (event.metaKey || event.ctrlKey) && (event.code === 'Slash' || event.code === 'Period' || event.key === '?' || event.key === '>')) {
+  if (!settingsUp && (event.metaKey || event.ctrlKey) && !event.altKey && (event.code === 'Slash' || event.code === 'Period' || event.key === '?' || event.key === '>')) {
     event.preventDefault();
     openMergedView((event.code === 'Slash' || event.key === '?') ? 'q' : 'c');
     return;
   }
-  if (!settingsUp && (event.metaKey || event.ctrlKey) && event.shiftKey && (event.code === 'KeyN' || event.key === 'n' || event.key === 'N')) {
+  if (!settingsUp && (event.metaKey || event.ctrlKey) && event.shiftKey && !event.altKey && (event.code === 'KeyN' || event.key === 'n' || event.key === 'N')) {
     event.preventDefault();
     openMemoView();
     return;
@@ -1116,7 +1175,7 @@ document.addEventListener('keydown', (event) => {
   // shortcuts (Cmd+1, F7, Cmd+[/], Cmd+B, …). Each has its own Esc + editing handlers.
   if (isFloatingModalOpen()) return;
 
-  if ((event.metaKey || event.ctrlKey) && event.key === '1') {
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === '1') {
     event.preventDefault();
     // Coming from the diff: open the file you were viewing as source so Cmd+1 lands ON it (not a stale/blank
     // source pane), and the tree below points at the same file. Capture the path BEFORE openSourceFile flips
@@ -1131,7 +1190,7 @@ document.addEventListener('keydown', (event) => {
     focusOpenFileInTree();
     return;
   }
-  if ((event.metaKey || event.ctrlKey) && event.key === '0') {
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === '0') {
     event.preventDefault();
     setTab('changes');
     focusOpenFileInTree();
@@ -1217,7 +1276,7 @@ document.addEventListener('keydown', (event) => {
   // PageUp/Down scroll the diff/source view. There's no focusable scroller (the diff caret is a JS cursor),
   // and d2h-file-side-diff's horizontal scrollport even swallows vertical wheel, so handle paging explicitly.
   // Only when the tree isn't focused — the tree pages itself in handleTreeKey below.
-  if (treeFocusIndex < 0 && (event.key === 'PageDown' || event.key === 'PageUp') && !event.metaKey && !event.ctrlKey && !event.altKey) {
+  if (treeFocusIndex < 0 && (event.key === 'PageDown' || event.key === 'PageUp') && !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey) {
     var psc = isDiffViewVisible() ? document.getElementById('diff2html-container') : (isSourceViewerVisible() ? document.getElementById('source-body') : null);
     if (psc) { event.preventDefault(); psc.scrollTop += (event.key === 'PageDown' ? 0.9 : -0.9) * psc.clientHeight; return; }
   }
@@ -1248,12 +1307,12 @@ document.addEventListener('keydown', (event) => {
     lastShiftSide = side;
   }
 
-  if ((event.metaKey || event.ctrlKey) && event.shiftKey && event.key.toLowerCase() === 'f') {
+  if ((event.metaKey || event.ctrlKey) && event.shiftKey && !event.altKey && event.key.toLowerCase() === 'f') {
     event.preventDefault();
     openQuickOpen('content');
     return;
   }
-  if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'e') {
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key.toLowerCase() === 'e') {
     event.preventDefault();
     openQuickOpen('recent');
     return;
@@ -1268,14 +1327,14 @@ document.addEventListener('keydown', (event) => {
     }
   }
 
-  if ((event.metaKey || event.ctrlKey) && event.key === 'ArrowDown') {
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === 'ArrowDown') {
     event.preventDefault();
     if (isSourceViewerVisible()) goToSymbolUnderCursor();
     else openDiffFileAtCaret();
     return;
   }
 
-  if ((event.metaKey || event.ctrlKey) && (event.key === 'b' || event.key === 'B')) {
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'b' || event.key === 'B')) {
     var aeB = document.activeElement;
     if (aeB && (aeB.tagName === 'INPUT' || aeB.tagName === 'TEXTAREA' || aeB.tagName === 'SELECT')) return;
     event.preventDefault();
@@ -1337,7 +1396,7 @@ document.addEventListener('keydown', (event) => {
     }
   }
 
-  if (event.key === 'F7') {
+  if (event.key === 'F7' && !event.metaKey && !event.ctrlKey && !event.altKey) {
     event.preventDefault();
     const delta = event.shiftKey ? -1 : 1;
     const sourceViewer = document.getElementById('source-viewer');
@@ -1414,6 +1473,19 @@ document.querySelectorAll('.tab').forEach((button) => {
   button.addEventListener('click', () => setTab(button.dataset.tab || 'changes'));
 });
 
+// Activity rail (IntelliJ-style): click an icon to navigate/toggle its view. Terminal + settings buttons
+// carry no data-view — they keep their own id-based handlers (terminal toggle / settings gear).
+document.querySelector('.activity-rail')?.addEventListener('click', (event) => {
+  const btn = event.target.closest && event.target.closest('.rail-btn[data-view]');
+  if (!btn) return;
+  const view = btn.dataset.view;
+  if (view === 'changes') { setTab('changes'); if (!isDiffViewVisible()) showDiffView(false); }
+  else if (view === 'files') { setTab('files'); }
+  else if (view === 'q' || view === 'c') { toggleMergedRail(view); }
+  else if (view === 'memo') { openMemoView(); } // openMemoView already toggles
+  syncRail();
+});
+
 document.getElementById('back-to-diff')?.addEventListener('click', () => showDiffView(true));
 document.getElementById('source-tabs')?.addEventListener('click', function (event) {
   var closeBtn = event.target && event.target.closest && event.target.closest('.source-tab-close');
@@ -1450,6 +1522,7 @@ if (!restored) {
   else openDefaultSourceFile();
 }
 initSourceTreeFolds();
+syncRail(); // reflect the initial view on the activity rail
 // Electron receives live updates over IPC (monacoriMenu.onDiffUpdate); only serve/browser needs the HTTP
 // poller. Under file:// its fetch just fails every 1.5s for the app's whole life, so skip it in Electron.
 if (watchEnabled && !(window.monacoriMenu && typeof window.monacoriMenu.onDiffUpdate === 'function')) {
@@ -1485,7 +1558,10 @@ window.addEventListener('beforeunload', saveUiState);
   });
   document.addEventListener('mousemove', (event) => {
     if (!resizing) return;
-    const width = Math.min(640, Math.max(180, event.clientX));
+    // Subtract the activity rail's width: the sidebar starts to its right, so its width is the cursor X
+    // minus the rail offset (not clientX itself, which would over-size it by the rail width).
+    const railW = parseFloat(getComputedStyle(document.body).getPropertyValue('--rail-width')) || 0;
+    const width = Math.min(640, Math.max(180, event.clientX - railW));
     document.documentElement.style.setProperty('--sidebar-width', width + 'px');
   });
   document.addEventListener('mouseup', () => {
@@ -1671,6 +1747,7 @@ function setDiffCursor(path, side, rowIndex, column, reveal) {
   var col = Math.max(0, Math.min(column, diffLineText(rows[ri]).length));
   diffCursor = { path: path, side: side, rowIndex: ri, column: col };
   pendingFileBoundary = null; // any caret move re-arms the last-change announcement for the next F7 (see next)
+  hideCaretHint(); // caret moved (incl. crossing to the next file) → drop the "last change" hint so it never covers the new file
   diffSelectionAnchor = null; // any direct caret placement (click/F7/Cmd-arrow) drops the selection; Shift+Arrow re-sets it
   if (reveal) {
     // Render the caret AND scroll in the SAME animation frame. A fast key-repeat queues several ArrowDowns
@@ -1911,6 +1988,28 @@ function showToast(message) {
     setTimeout(function () { if (el.parentNode) el.parentNode.removeChild(el); }, 300);
   }, 4500);
 }
+// Inline hint anchored just under the diff caret — used for the F7 "last change" boundary announcement so the
+// message appears where the user is looking and fades on its own (unlike the corner toast). Falls back to the
+// corner toast when there's no on-screen caret (e.g. source view).
+var caretHintEl = null, caretHintTimer = 0;
+function showCaretHint(message) {
+  var row = activeDiffRow || document.querySelector('#diff2html-container .diff-active-row');
+  if (!row || !row.getBoundingClientRect) { showToast(message); return; }
+  if (!caretHintEl) { caretHintEl = document.createElement('div'); caretHintEl.className = 'mc-caret-hint'; document.body.appendChild(caretHintEl); }
+  caretHintEl.textContent = message;
+  var r = row.getBoundingClientRect();
+  caretHintEl.style.left = Math.round(Math.max(8, r.left)) + 'px';
+  caretHintEl.style.top = Math.round(r.bottom + 4) + 'px';
+  caretHintEl.classList.remove('show');
+  void caretHintEl.offsetWidth; // reflow so the fade-in re-triggers on rapid repeat presses
+  caretHintEl.classList.add('show');
+  if (caretHintTimer) clearTimeout(caretHintTimer);
+  caretHintTimer = setTimeout(function () { if (caretHintEl) caretHintEl.classList.remove('show'); }, 2000);
+}
+function hideCaretHint() {
+  if (caretHintTimer) { clearTimeout(caretHintTimer); caretHintTimer = 0; }
+  if (caretHintEl) caretHintEl.classList.remove('show');
+}
 // Follow each comment to its snapshot line (c.code) in the current content: same line if unchanged, else the
 // nearest exact match of that line. A comment is NEVER auto-deleted. If its line can't be found we leave it
 // where it is — this happens routinely WITHOUT the file changing: a comment anchored to a deleted/old-side
@@ -2405,6 +2504,12 @@ function applyDockMaximized() {
   document.body.classList.toggle('dock-maximized', dockMaximized);
 }
 function toggleDockMaximized() {
+  // Maximize only the panel you're FOCUSED in: the merged/memo dock (.dock-panel) or the terminal
+  // (.terminal-panel). From the sidebar tree (treeFocusIndex >= 0) or the diff/source content this is a
+  // no-op — pressing it there must NOT maximize a terminal you aren't actually in.
+  if (treeFocusIndex >= 0) return;
+  var ae = document.activeElement;
+  if (!(ae && ae.closest && (ae.closest('.dock-panel') || ae.closest('.terminal-panel')))) return;
   if (!activeDockPanel()) return; // nothing docked -> nothing to maximize
   dockMaximized = !dockMaximized;
   applyDockMaximized();
@@ -2423,6 +2528,7 @@ function closeMergedMemoDocks() {
   // terminal dock but never for these floating panels.
   document.body.classList.toggle('floating-dock', !!(document.getElementById('mc-merged-panel') || document.getElementById('mc-memo-panel')));
   applyDockMaximized();
+  if (typeof syncRail === 'function') syncRail(); // clear the rail icon for the closed dock(s)
 }
 window.__monacoriCloseDocks = closeMergedMemoDocks;
 // Retry-focus a docked field (Electron async-restores focus to <body>, so a one-shot focus can lose the race).
@@ -2507,6 +2613,7 @@ function mountDock(id, titleText) {
   document.body.classList.add('dock-open');
   document.body.classList.add('floating-dock'); // scopes the maximize CSS so it doesn't hide the diff
   applyDockMaximized();
+  if (typeof syncRail === 'function') syncRail(); // light up the rail icon for the opened dock
   return { panel: panel, body: body, bar: bar, close: close };
 }
 
@@ -2681,6 +2788,7 @@ refreshComments();
 
   function setActive(p) {
     active = p;
+    if (p && p.labelEl) p.labelEl.classList.remove('has-bell'); // viewing the pane clears its bell badge
     panes.forEach(function (q) {
       q.el.classList.toggle('is-active', q === p);
       // 2+ panes: dim every pane but the active one (no border, just a clean focus cue). A lone pane stays full.
@@ -2694,6 +2802,11 @@ refreshComments();
     });
   }
 
+  function copyToClipboard(text) {
+    if (!text) return;
+    try { if (window.monacoriClipboard && window.monacoriClipboard.write) { window.monacoriClipboard.write(text); return; } } catch (e) {}
+    try { if (navigator.clipboard && navigator.clipboard.writeText) navigator.clipboard.writeText(text); } catch (e) {}
+  }
   function makePane() {
     if (!ensureXterm()) return null; // xterm unavailable — leave the panel empty rather than throw
     var el = document.createElement('div');
@@ -2729,6 +2842,9 @@ refreshComments();
         // Match the PHYSICAL key (e.code), not e.key: under a non-Latin layout/IME (e.g. Korean 한글)
         // Cmd+V reports e.key as 'ㅍ', so a key-based check misses it — blurring the terminal and
         // breaking paste/copy/cut/select-all whenever the Korean input source is active.
+        // Cmd+C with a terminal selection: copy it ourselves — xterm doesn't auto-copy and the menu/native
+        // copy misses xterm's own selection, so Cmd+C silently did nothing. No selection -> fall through.
+        if (e.code === 'KeyC' && term.hasSelection && term.hasSelection()) { copyToClipboard(term.getSelection()); return false; }
         if (e.code === 'KeyC' || e.code === 'KeyV' || e.code === 'KeyX' || e.code === 'KeyA') return true;
         try { term.blur(); } catch (x) {}
         return false;
@@ -2736,6 +2852,14 @@ refreshComments();
       return true;
     });
     term.onData(function (d) { if (pane.id != null) window.monacoriPty.write({ id: pane.id, data: d }); });
+    // Bell from the pane's TUI (e.g. Claude Code finished a turn / needs input): badge the pane when it isn't
+    // the one you're looking at, and ask the main process to raise a native notification when the whole window
+    // isn't focused. Toggle in Settings ("Notify when a terminal task finishes").
+    term.onBell(function () {
+      if (pane !== active && pane.labelEl) pane.labelEl.classList.add('has-bell');
+      if (persistRead('monacori-terminal-bell-notify') === false) return; // OS notifications disabled
+      try { window.monacoriPty.bell({ title: 'monacori', body: pane.name + ' — ' + t('notify.bellBody') }); } catch (e) {}
+    });
     el.addEventListener('mousedown', function (e) { if (e.target !== labelEl) setActive(pane); });
     labelEl.addEventListener('dblclick', function () { renamePane(pane); });
     panes.push(pane);
@@ -2783,10 +2907,12 @@ refreshComments();
   }
 
   function removePane(id) {
-    var i = -1;
-    for (var k = 0; k < panes.length; k++) { if (panes[k].id === id) { i = k; break; } }
+    for (var k = 0; k < panes.length; k++) { if (panes[k].id === id) { removePaneRef(panes[k]); return; } }
+  }
+  // Remove a pane by object reference (handles panes whose pty id hasn't arrived yet — spawn is async).
+  function removePaneRef(p) {
+    var i = panes.indexOf(p);
     if (i < 0) return;
-    var p = panes[i];
     try { p.term.dispose(); } catch (e) {}
     if (p.el.parentNode) p.el.parentNode.removeChild(p.el);
     panes.splice(i, 1);
@@ -2794,6 +2920,15 @@ refreshComments();
     if (panes.length === 0) setOpen(false);
     else fitAll();
   }
+  // Cmd/Ctrl+W inside the terminal: close just the FOCUSED pane (kill its pty), not the whole panel. The
+  // last pane closing collapses the panel via removePaneRef -> setOpen(false). Remove the pane immediately
+  // (don't wait for the pty's onExit) so the UI responds at once; the later onExit -> removePane no-ops.
+  function closeActivePane() {
+    var p = active || panes[panes.length - 1];
+    if (!p) { setOpen(false); return; }
+    if (p.id != null) { try { window.monacoriPty.kill({ id: p.id }); } catch (e) {} }
+    removePaneRef(p);
+  }
 
   function split() {
     if (panes.length >= MAX_PANES) return;
@@ -2927,8 +3062,12 @@ refreshComments();
   }, true);
   window.__monacoriTerminal = {
     isOpen: isOpen,
+    // True when keyboard focus is inside the terminal panel (a pane owns it) — Cmd/Ctrl+W uses this to
+    // decide between closing a pane and closing a source tab.
+    hasFocus: function () { var ae = document.activeElement; return !!(ae && panel.contains(ae)); },
     open: function () { setOpen(true); },
     paneCount: function () { return panes.length; },
+    closeActivePane: closeActivePane,
     enterSendMode: enterSendMode,
     send: function (text) { writeToPane(active || panes[0], text); },
     sendToPane: function (i, text) { writeToPane(panes[i] || active || panes[0], text); },
@@ -2956,10 +3095,11 @@ if (window.monacoriMenu && typeof window.monacoriMenu.onDiffUpdate === 'function
   window.monacoriMenu.onDiffUpdate(function (html) { try { applyDiffUpdate(html); } catch (e) {} });
 }
 if (window.monacoriMenu && typeof window.monacoriMenu.onCloseTab === 'function') {
-  // Cmd/Ctrl+W: close the active Files-mode tab (no-op outside the source viewer).
+  // Cmd/Ctrl+W: close whatever the focus is on. A focused terminal pane closes just that pane (the last
+  // pane collapses the panel); otherwise close the active Files-mode tab (no-op outside the source viewer).
   window.monacoriMenu.onCloseTab(function () {
-    // Cmd/Ctrl+W closes the terminal panel first when it's open, otherwise the active Files-mode tab.
-    if (window.__monacoriTerminal && window.__monacoriTerminal.isOpen()) { window.__monacoriTerminal.close(); return; }
+    var term = window.__monacoriTerminal;
+    if (term && term.isOpen() && term.hasFocus()) { term.closeActivePane(); return; }
     if (isSourceViewerVisible()) closeActiveSourceTab();
   });
 }
@@ -3070,6 +3210,12 @@ if (window.monacoriMenu && typeof window.monacoriMenu.onCloseTab === 'function')
   if (qta) qta.addEventListener('input', function () { saveMergePrompt('q', qta.value); flash(); });
   if (cta) cta.addEventListener('input', function () { saveMergePrompt('c', cta.value); flash(); });
   if (resetBtn) resetBtn.addEventListener('click', function () { saveMergePrompt('q', ''); saveMergePrompt('c', ''); fill(); flash(); });
+  // Terminal-bell notification toggle (default ON — persistRead returns undefined when never set).
+  var bellCb = document.getElementById('set-bell-notify');
+  if (bellCb) {
+    bellCb.checked = persistRead('monacori-terminal-bell-notify') !== false;
+    bellCb.addEventListener('change', function () { persistSave('monacori-terminal-bell-notify', bellCb.checked); });
+  }
   // Language: live-switch the whole UI (no reload). Persist, re-apply the static chrome, then re-render
   // any currently-shown dynamic text (open composer / merged modal / index status) so it follows too.
   langSelectRef = setupCustomSelect('settings-language',
@@ -3103,6 +3249,29 @@ function setTab(name) {
   });
   document.getElementById('changes-panel')?.classList.toggle('hidden', name !== 'changes');
   document.getElementById('files-panel')?.classList.toggle('hidden', name !== 'files');
+  syncRail();
+}
+// Reflect the current view/dock state on the activity rail icons (active highlight). Terminal active is
+// kept in sync separately by the dock-terminal setOpen (it toggles is-active on #terminal-toggle).
+function syncRail() {
+  var rail = document.querySelector('.activity-rail');
+  if (!rail) return;
+  var setOn = function (view, on) {
+    var btn = rail.querySelector('[data-view="' + view + '"]');
+    if (btn) btn.classList.toggle('is-active', !!on);
+  };
+  setOn('changes', !document.getElementById('changes-panel')?.classList.contains('hidden'));
+  setOn('files', !document.getElementById('files-panel')?.classList.contains('hidden'));
+  var merged = document.getElementById('mc-merged-panel');
+  setOn('q', !!(merged && merged.dataset.kind === 'q'));
+  setOn('c', !!(merged && merged.dataset.kind === 'c'));
+  setOn('memo', !!document.getElementById('mc-memo-panel'));
+}
+// Rail click for the merged views toggles: a 2nd click on the open kind closes it (memo already toggles).
+function toggleMergedRail(kind) {
+  var m = document.getElementById('mc-merged-panel');
+  if (m && m.dataset.kind === kind) { closeMergedMemoDocks(); return; }
+  openMergedView(kind);
 }
 // Big repos ship the source tree as an inert island (see render.ts); build it the first time the Files
 // tab is opened so the (potentially huge) tree never blocks startup. No-op for inline (small) trees.
@@ -3218,6 +3387,10 @@ function applyDiffUpdate(u) {
   var wasSource = isSourceViewerVisible();
   var container = document.getElementById('diff2html-container');
   var diffScrollTop = container ? container.scrollTop : 0;
+  // The active hunk's file path BEFORE the swap (hunkMeta/hunks still hold the old build here). After a commit
+  // the old active file can vanish from the new diff, so we re-anchor `current` to it below — otherwise it
+  // dangles at a stale index and showDiffView renders blank with a stale breadcrumb.
+  var prevActivePath = current >= 0 ? hunkPathAt(current) : '';
   // Did the file the user is CURRENTLY viewing actually change in this build? If not, we must not re-render
   // the source view — an unrelated file's edit would otherwise flicker the pane they're reading. Capture the
   // open file's signature BEFORE fileSignatureByPath is rebuilt below.
@@ -3248,6 +3421,13 @@ function applyDiffUpdate(u) {
   if (filesPanel && (!REVIEW_LAZY || filesPanel.innerHTML.trim())) filesPanel.innerHTML = u.filesTree || '';
   var statusEl = document.querySelector('.review-status');
   if (statusEl) statusEl.innerHTML = u.reviewStatus || '';
+  // Branch can change between watch ticks (checkout/commit) — keep the sidebar chip current.
+  var branchName = document.getElementById('brand-branch-name');
+  if (branchName) {
+    branchName.textContent = u.branch || '';
+    var branchChip = branchName.closest && branchName.closest('.brand-branch');
+    if (branchChip) branchChip.classList.toggle('hidden', !u.branch);
+  }
   if (reviewMeta) { reviewMeta.setAttribute('data-signature', u.signature); if (u.generatedAt) reviewMeta.setAttribute('data-generated-at', u.generatedAt); }
 
   // 2) Re-derive module-level state directly from the payload objects.
@@ -3264,6 +3444,16 @@ function applyDiffUpdate(u) {
   links = Array.from(document.querySelectorAll('#changes-panel .file-link'));
   sourceLinks = Array.from(document.querySelectorAll('.source-link'));
 
+  // Reconcile the active hunk against the new build (uses the just-rebuilt `links`). A committed/removed file
+  // reshuffles or shrinks the diff: re-anchor `current` to the same file's new hunk when it survives, else
+  // drop to -1 so the diff lands on the first change rather than a dangling index that paints nothing.
+  var activeFilePreserved = false;
+  if (prevActivePath) {
+    var reHunk = firstHunkForPath(prevActivePath);
+    if (reHunk >= 0) { current = reHunk; activeFilePreserved = true; }
+    else current = -1;
+  }
+
   // 3) Reset lazy-materialize + index state so the new diff bodies / source / symbols rebuild on demand.
   // bodyCache is keyed by file INDEX, not content — after a watch rebuild the same index maps to the new
   // body, so it MUST be dropped too. Clearing only bodyPromise left loadBodyHtml() returning the cached
@@ -3277,14 +3467,11 @@ function applyDiffUpdate(u) {
   // sourceBodyPath so the already-painted (unchanged) source view is left exactly as-is — no flicker.
   if (openFileChanged) sourceBodyPath = null;
   symbolIndex = null;
-  if (REVIEW_LAZY) { setupLazyDiff(); setTimeout(function () { diffBootDone = true; }, 0); }
-  else { prepareDiff2HtmlHunks(); diffBootDone = true; }
-  if (!REVIEW_LAZY_LOAD) setTimeout(startSymbolIndex, 0);
 
   // 3b) Re-fill UNCHANGED files' bodies synchronously from the snapshot so they don't blank-then-reload (the
-  // flicker). The fresh wrapper carries the correct data-first-hunk + file index, so materializeBody numbers
-  // hunks exactly as a normal lazy load would — this only skips the IPC round-trip for files whose content is
-  // identical. Changed/new files stay shells and lazy-load as usual, so a real edit still refreshes the diff.
+  // flicker). Runs BEFORE setupLazyDiff so the IntersectionObserver sees them already materialized and never
+  // re-fetches them. The fresh wrapper carries the correct data-first-hunk + file index, so materializeBody
+  // numbers hunks exactly as a normal lazy load would. Changed/new files stay shells and lazy-load as usual.
   if (REVIEW_LAZY && container) {
     container.querySelectorAll('.d2h-file-wrapper').forEach(function (w) {
       var p = diffWrapperPathKey(w);
@@ -3298,6 +3485,10 @@ function applyDiffUpdate(u) {
       bodyPromise[idx] = Promise.resolve(w);
     });
   }
+  refreshHunkIndex(); // rebuild hunks/hunkMeta from the swapped-in DOM so hunkTotal()/hunkPathAt() aren't stale
+  if (REVIEW_LAZY) { setupLazyDiff(); setTimeout(function () { diffBootDone = true; }, 0); }
+  else { diffBootDone = true; }
+  if (!REVIEW_LAZY_LOAD) setTimeout(startSymbolIndex, 0);
 
   // 4) Re-run the DOM-dependent bootstrap steps.
   applyI18n();
@@ -3312,7 +3503,10 @@ function applyDiffUpdate(u) {
     if (openFileChanged) openSourceFile(openPath, false);
   } else if (container) {
     showDiffView(false);
-    container.scrollTop = diffScrollTop;
+    // Same active file survived → keep the user's exact scroll. If it was committed away (current reset to
+    // -1, showDiffView landed on the first change), restoring the old, now-out-of-range scrollTop would push
+    // the shorter new diff off-screen and look blank — so reset to the top instead.
+    container.scrollTop = activeFilePreserved ? diffScrollTop : 0;
   }
   return true;
 }
@@ -3961,6 +4155,39 @@ function showUsages(name, count) {
   if (title) title.textContent = count + ' usage' + (count === 1 ? '' : 's') + ' of ' + name;
   renderUsages();
   box.classList.remove('hidden');
+  positionUsagesAtCaret();
+}
+// Anchor the usages popup just below (or above, if cramped) the live caret — source OR diff both render a
+// `.code-cursor` span. No caret on screen → leave the centered overlay fallback in place.
+function positionUsagesAtCaret() {
+  var box = document.getElementById('usages');
+  if (!box) return;
+  var panel = box.querySelector('.quick-open-panel');
+  if (!panel) return;
+  resetUsagesAnchor(box, panel); // measure from a clean slate
+  var caret = document.querySelector('#source-body .code-cursor') || document.querySelector('#diff2html-container .code-cursor');
+  if (!caret) return;
+  var rect = caret.getBoundingClientRect();
+  if (!rect.height && !rect.width && !rect.top) return; // detached / off-layout
+  var vw = window.innerWidth, vh = window.innerHeight, gap = 6, margin = 8;
+  var pw = Math.min(560, vw - margin * 2);
+  var left = Math.min(Math.max(margin, rect.left), vw - pw - margin);
+  box.classList.add('anchored');
+  panel.style.width = pw + 'px';
+  panel.style.left = left + 'px';
+  var spaceBelow = vh - rect.bottom - gap - margin;
+  var spaceAbove = rect.top - gap - margin;
+  if (spaceBelow >= 200 || spaceBelow >= spaceAbove) {
+    panel.style.top = (rect.bottom + gap) + 'px';
+    panel.style.maxHeight = Math.max(120, spaceBelow) + 'px';
+  } else {
+    panel.style.bottom = (vh - rect.top + gap) + 'px';
+    panel.style.maxHeight = Math.max(120, spaceAbove) + 'px';
+  }
+}
+function resetUsagesAnchor(box, panel) {
+  box.classList.remove('anchored');
+  panel.style.left = panel.style.top = panel.style.bottom = panel.style.width = panel.style.maxHeight = '';
 }
 function renderUsages() {
   var results = document.getElementById('usages-results');
@@ -3998,7 +4225,11 @@ function openUsageItem(item) {
   openSourceAt(item.path, item.lineIndex, item.column);
 }
 function closeUsages() {
-  document.getElementById('usages')?.classList.add('hidden');
+  var box = document.getElementById('usages');
+  if (!box) return;
+  box.classList.add('hidden');
+  var panel = box.querySelector('.quick-open-panel');
+  if (panel) resetUsagesAnchor(box, panel); // clear inline anchoring so the next open re-measures cleanly
 }
 
 var symbolIndex = null; // Map<name, [{path,lineIndex,column}]>; built off-thread by a Web Worker, null until ready
@@ -4176,11 +4407,18 @@ function renderSourceTabs(activePath) {
     var active = p === activePath;
     return '<div class="source-tab' + (active ? ' active' : '') + '" data-tab-path="' + escapeHtml(p) + '" title="' + escapeHtml(p) + '">'
       + '<span class="source-tab-name">' + escapeHtml(sourceTabLabel(p)) + '</span>'
-      + '<button type="button" class="source-tab-close" data-close-path="' + escapeHtml(p) + '" aria-label="Close tab" title="Close (Cmd/Ctrl+W)">×</button>'
+      + '<button type="button" class="source-tab-close" data-close-path="' + escapeHtml(p) + '" aria-label="Close tab" title="Close (⌘W)">×</button>'
       + '</div>';
   }).join('');
+  // Scroll the tab bar HORIZONTALLY only. scrollIntoView() walks every scrollable ancestor — on rapid
+  // Cmd+Shift+[/] cycling it nudged a vertical ancestor and clipped the tab strip at the top. Adjusting
+  // bar.scrollLeft directly keeps the active tab in view without ever touching vertical scroll.
   var act = bar.querySelector('.source-tab.active');
-  if (act && act.scrollIntoView) act.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+  if (act) {
+    var bl = bar.getBoundingClientRect(), al = act.getBoundingClientRect();
+    if (al.left < bl.left) bar.scrollLeft -= (bl.left - al.left) + 8;
+    else if (al.right > bl.right) bar.scrollLeft += (al.right - bl.right) + 8;
+  }
 }
 function closeSourceTab(path) {
   var idx = sourceTabs.indexOf(path);
@@ -4653,7 +4891,7 @@ function renderHttpTable(file) {
     const reqIdx = hasRun ? runAtLine[index] : -1;
     const isCursorLine = Boolean(cursor && cursor.lineIndex === index);
     const gutter = hasRun
-      ? '<button type="button" class="http-run" data-req="' + reqIdx + '" title="Run request (Cmd/Alt+Enter)" aria-label="Run request">&#9654;</button>'
+      ? '<button type="button" class="http-run" data-req="' + reqIdx + '" title="Run request (⌘Enter / ⌥Enter)" aria-label="Run request">&#9654;</button>'
       : '';
     rows += '<tr class="source-row http-row' + (hasRun ? ' http-request-line' : '') + (isCursorLine ? ' cursor-line' : '') + '" data-line-index="' + index + '">'
       + '<td class="num http-gutter">' + gutter + '<span class="num-text">' + (index + 1) + '</span></td>'