@happy-nut/monacori 0.1.21 → 0.1.23

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') {
@@ -1041,6 +1100,11 @@ function handleTreeKey(event) {
   if (event.key === 'ArrowUp') { event.preventDefault(); focusTree(treeFocusIndex - 1); return true; }
   if (event.key === 'PageDown') { event.preventDefault(); focusTree(treeFocusIndex + treePageSize()); return true; }
   if (event.key === 'PageUp') { event.preventDefault(); focusTree(treeFocusIndex - treePageSize()); return true; }
+  if (event.key === 'Enter' && event.altKey) {
+    event.preventDefault();
+    if (row && typeof openTreeRowMenu === 'function') openTreeRowMenu(row); // copy path / Finder / terminal
+    return true;
+  }
   if (event.key === 'Enter') {
     event.preventDefault();
     if (row && row.classList.contains('file-link')) { row.click(); clearTreeFocus(); }
@@ -1078,6 +1142,9 @@ function handleTreeKey(event) {
 function isFloatingModalOpen() {
   var sm = document.getElementById('settings-modal');
   if (sm && !sm.classList.contains('hidden')) return true;
+  var hv = document.getElementById('history-view');
+  if (hv && !hv.classList.contains('hidden')) return true; // history overlay owns the keys (Esc/filter/click)
+  if (document.getElementById('goto-line')) return true; // go-to-line prompt owns the keys until Enter/Esc
   // The merged/memo panels are now docked (inline), not overlays — but while one OWNS focus we still stand
   // down the global nav shortcuts so typing / ▲▼ inside it isn't hijacked. Focus elsewhere -> shortcuts run.
   return isDockFocused();
@@ -1096,27 +1163,33 @@ 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;
   }
+  // Cmd/Ctrl+9 toggles the git history view (above the focus guard so a 2nd press closes it from inside).
+  if (!settingsUp && (event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.code === 'Digit9' || event.key === '9') && typeof toggleHistory === 'function') {
+    event.preventDefault();
+    toggleHistory();
+    return;
+  }
 
   // Settings overlay (or a focused merged/memo dock) captures keys: stand down the rest of the global
   // 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 +1204,25 @@ document.addEventListener('keydown', (event) => {
     focusOpenFileInTree();
     return;
   }
-  if ((event.metaKey || event.ctrlKey) && event.key === '0') {
+  // Cmd/Ctrl+L = go to line (numeric prompt); Cmd/Ctrl+K = copy the caret's file:line. Skip when an
+  // editable field owns focus (a comment composer textarea) so we don't hijack the user's typing.
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'l' || event.key === 'L')) {
+    var lkae = document.activeElement;
+    if (!(lkae && (lkae.tagName === 'INPUT' || lkae.tagName === 'TEXTAREA' || lkae.tagName === 'SELECT'))) {
+      event.preventDefault();
+      openGotoLine();
+      return;
+    }
+  }
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'k' || event.key === 'K')) {
+    var kkae = document.activeElement;
+    if (!(kkae && (kkae.tagName === 'INPUT' || kkae.tagName === 'TEXTAREA' || kkae.tagName === 'SELECT'))) {
+      event.preventDefault();
+      copyCaretLocation();
+      return;
+    }
+  }
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === '0') {
     event.preventDefault();
     setTab('changes');
     focusOpenFileInTree();
@@ -1217,7 +1308,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 +1339,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 +1359,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 +1428,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 +1505,20 @@ 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
+  else if (view === 'history') { toggleHistory(); }
+  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 +1555,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 +1591,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 +1780,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 +2021,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 +2537,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 +2561,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 +2646,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 +2821,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 +2835,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 +2875,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 +2885,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 +2940,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 +2953,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 +3095,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 +3128,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 +3243,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 +3282,31 @@ 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'));
+  var hv = document.getElementById('history-view');
+  setOn('history', !!(hv && !hv.classList.contains('hidden')));
+}
+// 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 +3422,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 +3456,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 +3479,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 +3502,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 +3520,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 +3538,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 +4190,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 +4260,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 +4442,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 +4926,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>'
@@ -4937,3 +5210,328 @@ function formatBytes(bytes) {
   if (kib < 1024) return kib.toFixed(1) + ' KiB';
   return (kib / 1024).toFixed(1) + ' MiB';
 }
+// ===== Git history view (Cmd+9): commit list with graph lanes + per-commit diff. =====
+// Data comes from the main process (window.monacoriGit.log / .commitDiff); the lane layout is computed
+// here from each commit's parents. Read-only — the per-commit diff is static diff2html HTML.
+
+var HISTORY_LANE_W = 14, HISTORY_DOT_R = 3.5, HISTORY_ROW_H = 24;
+var HISTORY_COLORS = ['#6c9fd4', '#7faf6b', '#d4a857', '#c77dd4', '#d36c6c', '#5bb6b6', '#b0884f', '#8d8df0'];
+var historyCommits = [];
+var historyGraph = [];
+var historyMaxLane = 0;
+var historyActiveSha = '';
+var historyLoading = false;
+
+// Lane layout. Walks commits newest-first, tracking open edges (lanes) by the hash each expects next.
+// Returns per-row { hash, myLane, color, topEdges, bottomEdges } using LANE INDICES + COLOR INDICES (px-free,
+// so it's unit-testable). First parent inherits the commit's color so a branch keeps one hue down its line.
+function computeHistoryGraph(commits) {
+  var lanes = [];           // lane index -> hash the lane is waiting to reach (open edge from above)
+  var colorOf = {};         // hash -> color index
+  var next = 0;
+  function colorFor(h) { if (colorOf[h] == null) colorOf[h] = next++; return colorOf[h]; }
+  function freeLane() { for (var i = 0; i < lanes.length; i++) if (lanes[i] == null) return i; lanes.push(null); return lanes.length - 1; }
+  var rows = [];
+  var maxLane = 0;
+  for (var ci = 0; ci < commits.length; ci++) {
+    var c = commits[ci];
+    var incoming = lanes.slice();
+    var myLane = lanes.indexOf(c.hash);
+    if (myLane === -1) myLane = freeLane();
+    var myColor = colorFor(c.hash);
+    lanes[myLane] = c.hash;
+    for (var i = 0; i < lanes.length; i++) if (i !== myLane && lanes[i] === c.hash) lanes[i] = null; // merge other edges in
+    var parents = c.parents || [];
+    var parentLanes = {};
+    if (parents.length === 0) {
+      lanes[myLane] = null; // root commit — the lane ends here
+    } else {
+      lanes[myLane] = parents[0];
+      if (colorOf[parents[0]] == null) colorOf[parents[0]] = myColor; // first parent keeps the hue
+      parentLanes[myLane] = true;
+      for (var p = 1; p < parents.length; p++) {
+        var ex = lanes.indexOf(parents[p]);
+        var l = ex !== -1 ? ex : freeLane();
+        lanes[l] = parents[p];
+        colorFor(parents[p]);
+        parentLanes[l] = true;
+      }
+    }
+    var outgoing = lanes.slice();
+    var topEdges = [];
+    for (var a = 0; a < incoming.length; a++) {
+      if (incoming[a] == null) continue;
+      topEdges.push({ from: a, to: incoming[a] === c.hash ? myLane : a, color: colorOf[incoming[a]] });
+    }
+    var bottomEdges = [];
+    for (var b = 0; b < outgoing.length; b++) {
+      if (outgoing[b] == null) continue;
+      bottomEdges.push({ from: parentLanes[b] ? myLane : b, to: b, color: colorOf[outgoing[b]] });
+    }
+    for (var m = 0; m < Math.max(incoming.length, outgoing.length); m++) {
+      if (incoming[m] != null || outgoing[m] != null) maxLane = Math.max(maxLane, m);
+    }
+    maxLane = Math.max(maxLane, myLane);
+    rows.push({ hash: c.hash, myLane: myLane, color: myColor, topEdges: topEdges, bottomEdges: bottomEdges });
+  }
+  rows.maxLane = maxLane;
+  return rows;
+}
+if (typeof window !== 'undefined') window.computeHistoryGraph = computeHistoryGraph; // exposed for tests
+
+function historyLaneX(l) { return 9 + l * HISTORY_LANE_W; }
+function historyColor(i) { return HISTORY_COLORS[i % HISTORY_COLORS.length]; }
+function historyRowSvg(row) {
+  var w = historyLaneX(historyMaxLane) + 9, h = HISTORY_ROW_H, mid = h / 2;
+  var s = '<svg class="hgraph" width="' + w + '" height="' + h + '" viewBox="0 0 ' + w + ' ' + h + '" aria-hidden="true">';
+  var edge = function (e, y1, y2) {
+    var x1 = historyLaneX(e.from), x2 = historyLaneX(e.to);
+    var c1 = (y1 + y2) / 2;
+    return '<path d="M' + x1 + ' ' + y1 + ' C ' + x1 + ' ' + c1 + ', ' + x2 + ' ' + c1 + ', ' + x2 + ' ' + y2 + '" stroke="' + historyColor(e.color) + '" fill="none" stroke-width="1.6"/>';
+  };
+  row.topEdges.forEach(function (e) { s += edge(e, 0, mid); });
+  row.bottomEdges.forEach(function (e) { s += edge(e, mid, h); });
+  s += '<circle cx="' + historyLaneX(row.myLane) + '" cy="' + mid + '" r="' + HISTORY_DOT_R + '" fill="' + historyColor(row.color) + '"/></svg>';
+  return s;
+}
+
+// "HEAD -> main, origin/main, tag: v1" -> small badges (HEAD/branch/tag styled distinctly).
+function historyRefBadges(refs) {
+  if (!refs || !refs.trim()) return '';
+  return refs.split(',').map(function (r) {
+    r = r.trim();
+    if (!r) return '';
+    var cls = 'href-branch', label = r;
+    if (r.indexOf('tag:') === 0) { cls = 'href-tag'; label = r.replace('tag:', '').trim(); }
+    else if (r.indexOf('HEAD') === 0) { cls = 'href-head'; }
+    else if (r.indexOf('origin/') === 0 || r.indexOf('/') !== -1) { cls = 'href-remote'; }
+    return '<span class="href ' + cls + '">' + escapeHtml(label) + '</span>';
+  }).join('');
+}
+
+function historyShortDate(iso) {
+  if (!iso) return '';
+  // 2026-06-20T21:03:11+09:00 -> "2026-06-20 21:03"
+  var m = String(iso).match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/);
+  return m ? m[1] + ' ' + m[2] : String(iso).slice(0, 16);
+}
+
+function renderHistoryList() {
+  var list = document.getElementById('history-list');
+  if (!list) return;
+  if (!historyCommits.length) {
+    list.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t(historyLoading ? 'history.loading' : 'history.empty')) + '</div>';
+    return;
+  }
+  list.style.setProperty('--hgraph-w', (historyLaneX(historyMaxLane) + 9) + 'px');
+  list.innerHTML = historyCommits.map(function (c, i) {
+    return '<button type="button" class="hrow' + (c.hash === historyActiveSha ? ' active' : '') + '" data-sha="' + escapeHtml(c.hash) + '">'
+      + '<span class="hgraph-cell">' + historyRowSvg(historyGraph[i]) + '</span>'
+      + '<span class="hmsg">' + historyRefBadges(c.refs) + escapeHtml(c.subject) + '</span>'
+      + '<span class="hauthor">' + escapeHtml(c.author) + '</span>'
+      + '<span class="hdate">' + escapeHtml(historyShortDate(c.date)) + '</span>'
+      + '</button>';
+  }).join('');
+}
+
+// Text filter (subject / author). The graph only reads right on the full contiguous history, so filtering
+// hides the graph column (IntelliJ does the same) and just shows matching rows.
+function applyHistoryFilter() {
+  var input = document.getElementById('history-search');
+  var list = document.getElementById('history-list');
+  if (!list) return;
+  var q = (input && input.value || '').trim().toLowerCase();
+  list.classList.toggle('filtering', q.length > 0);
+  var rows = list.querySelectorAll('.hrow');
+  for (var i = 0; i < rows.length; i++) {
+    var c = historyCommits[i];
+    var hit = !q || (c.subject + '\n' + c.author + '\n' + c.hash).toLowerCase().indexOf(q) !== -1;
+    rows[i].classList.toggle('hidden', !hit);
+  }
+}
+
+function openHistoryCommit(sha) {
+  if (!sha || !window.monacoriGit) return;
+  historyActiveSha = sha;
+  var list = document.getElementById('history-list');
+  if (list) list.querySelectorAll('.hrow').forEach(function (r) { r.classList.toggle('active', r.dataset.sha === sha); });
+  var detail = document.getElementById('history-detail');
+  if (detail) detail.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t('history.loading')) + '</div>';
+  Promise.resolve(window.monacoriGit.commitDiff(sha)).then(function (d) {
+    if (!d || historyActiveSha !== sha) return; // selection moved on while loading
+    renderHistoryDetail(d);
+  }, function () {});
+}
+
+function renderHistoryDetail(d) {
+  var detail = document.getElementById('history-detail');
+  if (!detail) return;
+  var head = '<div class="history-detail-head">'
+    + '<div class="hd-msg">' + escapeHtml(d.message || '').replace(/\n/g, '<br>') + '</div>'
+    + '<div class="hd-meta"><span class="hd-hash">' + escapeHtml((d.hash || '').slice(0, 10)) + '</span>'
+    + '<span class="hd-author">' + escapeHtml(d.author) + (d.email ? ' &lt;' + escapeHtml(d.email) + '&gt;' : '') + '</span>'
+    + '<span class="hd-date">' + escapeHtml(historyShortDate(d.date)) + '</span>'
+    + historyRefBadges(d.refs) + '</div></div>';
+  var body = (d.diffHtml && d.diffHtml.trim())
+    ? '<div class="history-diff diff2html-container">' + d.diffHtml + '</div>'
+    : '<div class="quick-open-empty">' + escapeHtml(t(d.isMerge ? 'history.merge' : 'history.noDiff')) + '</div>';
+  detail.innerHTML = head + body;
+}
+
+function isHistoryOpen() {
+  var v = document.getElementById('history-view');
+  return !!(v && !v.classList.contains('hidden'));
+}
+function closeHistory() {
+  var v = document.getElementById('history-view');
+  if (v) v.classList.add('hidden');
+  if (typeof syncRail === 'function') syncRail();
+}
+function openHistory() {
+  var v = document.getElementById('history-view');
+  if (!v) return;
+  if (!window.monacoriGit) return; // browser/serve mode: no git bridge
+  v.classList.remove('hidden');
+  if (typeof syncRail === 'function') syncRail();
+  var search = document.getElementById('history-search');
+  if (search) { search.value = ''; }
+  applyHistoryFilter();
+  historyLoading = true;
+  renderHistoryList();
+  Promise.resolve(window.monacoriGit.log({ limit: 300 })).then(function (commits) {
+    historyLoading = false;
+    historyCommits = Array.isArray(commits) ? commits : [];
+    historyGraph = computeHistoryGraph(historyCommits);
+    historyMaxLane = historyGraph.maxLane || 0;
+    renderHistoryList();
+    var detail = document.getElementById('history-detail');
+    if (detail) detail.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t('history.selectCommit')) + '</div>';
+    if (historyCommits[0]) openHistoryCommit(historyCommits[0].hash); // preview the newest commit
+    if (search) setTimeout(function () { try { search.focus(); } catch (e) {} }, 0);
+  }, function () { historyLoading = false; renderHistoryList(); });
+}
+function toggleHistory() { if (isHistoryOpen()) closeHistory(); else openHistory(); }
+if (typeof window !== 'undefined') window.__monacoriHistory = { open: openHistory, close: closeHistory, toggle: toggleHistory, isOpen: isHistoryOpen };
+
+(function wireHistory() {
+  var list = document.getElementById('history-list');
+  if (list) list.addEventListener('click', function (e) {
+    var row = e.target.closest && e.target.closest('.hrow[data-sha]');
+    if (row) openHistoryCommit(row.dataset.sha);
+  });
+  var search = document.getElementById('history-search');
+  if (search) search.addEventListener('input', applyHistoryFilter);
+  var closeBtn = document.getElementById('history-close');
+  if (closeBtn) closeBtn.addEventListener('click', closeHistory);
+  var view = document.getElementById('history-view');
+  if (view) view.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); closeHistory(); }
+  });
+})();
+// ===== Go-to-line (Cmd/Ctrl+L), copy caret location (Cmd/Ctrl+K), and the sidebar row action menu. =====
+
+// Programmatic clipboard write. Electron's bridge is reliable on file://; navigator.clipboard is the fallback.
+function copyTextToClipboard(text) {
+  try { if (window.monacoriClipboard && typeof window.monacoriClipboard.write === 'function') { window.monacoriClipboard.write(text); return true; } } catch (e) {}
+  try { if (navigator.clipboard && navigator.clipboard.writeText) { navigator.clipboard.writeText(text); return true; } } catch (e) {}
+  return false;
+}
+
+// "path:line" for the current caret — source view (the painted file) or the diff caret. '' if neither.
+function caretLocation() {
+  if (typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) {
+    var sv = document.getElementById('source-viewer');
+    var p = (sv && sv.dataset.openPath) || '';
+    if (p && typeof viewerCursor !== 'undefined' && viewerCursor && viewerCursor.path === p) return p + ':' + (viewerCursor.lineIndex + 1);
+    if (p) return p;
+  }
+  if (typeof isDiffViewVisible === 'function' && isDiffViewVisible() && typeof diffCursor !== 'undefined' && diffCursor) {
+    var wrap = diffWrapperByPath(diffCursor.path);
+    var row = wrap ? diffRowAt(wrap, diffCursor.side, diffCursor.rowIndex) : null;
+    var ln = row ? diffLineNumber(row) : null;
+    return diffCursor.path + (ln ? ':' + ln : '');
+  }
+  return '';
+}
+
+// Cmd/Ctrl+K — copy the caret's file:line to the clipboard.
+function copyCaretLocation() {
+  var loc = caretLocation();
+  if (!loc) return;
+  if (copyTextToClipboard(loc) && typeof showToast === 'function') showToast(t('goto.copied') + ' ' + loc);
+}
+
+// Diff view: place the caret on the row whose (new, then old) line number matches n, in the active file.
+function gotoDiffLine(n) {
+  var path = (typeof diffCursor !== 'undefined' && diffCursor && diffCursor.path) || '';
+  if (!path && typeof diffActiveWrapper === 'function') {
+    var w = diffActiveWrapper();
+    var nm = w && w.querySelector('.d2h-file-name');
+    if (nm && nm.textContent) path = nm.textContent.trim();
+  }
+  var wrap = path && diffWrapperByPath(path);
+  if (!wrap) return;
+  var sides = [(diffCursor && diffCursor.side) || 'new', 'new', 'old'];
+  for (var s = 0; s < sides.length; s++) {
+    var rows = diffRowsOf(diffSideTable(wrap, sides[s]));
+    for (var i = 0; i < rows.length; i++) {
+      if (diffLineNumber(rows[i]) === n) { setDiffCursor(path, sides[s], i, 0, true); return; }
+    }
+  }
+}
+
+function gotoLineJump(n) {
+  if (!(n >= 1)) return;
+  if (typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) {
+    var sv = document.getElementById('source-viewer');
+    var p = (sv && sv.dataset.openPath) || '';
+    var f = p && sourceByPath.get(p);
+    if (f && f.embedded && typeof f.content === 'string') {
+      var max = f.content.split(/\r?\n/).length;
+      setSourceCursor(p, Math.max(0, Math.min(max - 1, n - 1)), 0, true, -1);
+      return;
+    }
+  }
+  if (typeof isDiffViewVisible === 'function' && isDiffViewVisible()) gotoDiffLine(n);
+}
+
+// Cmd/Ctrl+L — a small numeric prompt; Enter jumps, Esc closes.
+function openGotoLine() {
+  if (!((typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) || (typeof isDiffViewVisible === 'function' && isDiffViewVisible()))) return;
+  var prior = document.getElementById('goto-line');
+  if (prior) prior.remove();
+  var box = document.createElement('div');
+  box.id = 'goto-line';
+  box.className = 'goto-line';
+  var input = document.createElement('input');
+  input.type = 'text';
+  input.inputMode = 'numeric';
+  input.className = 'goto-line-input';
+  input.placeholder = t('goto.placeholder');
+  box.appendChild(input);
+  document.body.appendChild(box);
+  function close() { box.remove(); document.removeEventListener('keydown', onKey, true); }
+  function onKey(e) {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); }
+    else if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); var n = parseInt(input.value, 10); close(); if (n >= 1) gotoLineJump(n); }
+  }
+  // Capture phase so Enter/Esc are handled here before the global keymap (which is on bubble).
+  document.addEventListener('keydown', onKey, true);
+  setTimeout(function () { try { input.focus(); } catch (e) {} }, 0);
+}
+
+// Sidebar Opt+Enter: actions for a focused file row (copy path / reveal in Finder / open terminal here).
+function openTreeRowMenu(row) {
+  if (!row) return;
+  var path = row.dataset.sourceFile || row.dataset.file || '';
+  if (!path) return;
+  var r = row.getBoundingClientRect();
+  var items = [
+    { label: t('menu.copyPath'), onSelect: function () { if (copyTextToClipboard(path) && typeof showToast === 'function') showToast(t('goto.copied') + ' ' + path); } },
+  ];
+  if (window.monacoriApp && typeof window.monacoriApp.revealInFinder === 'function') {
+    items.push({ label: t('menu.revealFinder'), onSelect: function () { try { window.monacoriApp.revealInFinder(path); } catch (e) {} } });
+    items.push({ label: t('menu.openTerminal'), onSelect: function () { try { window.monacoriApp.openTerminalAt(path); } catch (e) {} } });
+  }
+  showCustomDropdown(Math.round(r.left + 14), Math.round(r.bottom + 2), items, Math.round(r.top));
+}