@happy-nut/monacori 0.1.20 → 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) {
@@ -98,14 +119,19 @@ function whenFileReady(wrapper, cb) {
   if (bodyPromise[idx]) { bodyPromise[idx].then(function () { cb(); }); return; }
   cb();
 }
+var lazyIO = null; // remembered so each setupLazyDiff (re-run on every watch refresh) disconnects the prior
+                   // observer instead of leaving a new one bound to detached wrappers — otherwise observers
+                   // (and the old DOM they retain) pile up over a long-running session and slowly choke it.
 function setupLazyDiff() {
   var container = document.getElementById('diff2html-container');
   if (!container) return;
+  if (lazyIO) { try { lazyIO.disconnect(); } catch (e) {} lazyIO = null; }
   var wrappers = Array.prototype.slice.call(container.querySelectorAll('.d2h-file-wrapper'));
   if (typeof IntersectionObserver !== 'undefined') {
     var io = new IntersectionObserver(function (entries) {
       entries.forEach(function (e) { if (e.isIntersecting) { ensureFileReady(e.target); io.unobserve(e.target); } });
     }, { root: null, rootMargin: '600px 0px' });
+    lazyIO = io; // track this observer so the NEXT setupLazyDiff can disconnect it (callback keeps using local io)
     wrappers.forEach(function (w) { io.observe(w); });
   } else {
     wrappers.forEach(function (w) { ensureFileReady(w); }); // no IntersectionObserver -> materialize all
@@ -251,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;
@@ -258,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;
@@ -508,7 +536,7 @@ function revealAt(el, scroller, fraction) {
 }
 // Scrolloff variant: scroll ONLY when `el` would otherwise leave the viewport, keeping it within `marginFrac`
 // of the top/bottom edge. While the row moves comfortably inside that band the view stays put — continuous
-// centering scrolled the file even when everything was visible (dizzying). Used by the diff caret.
+// centering scrolled the file even when everything was visible (dizzying). Used by the diff caret and the sidebar tree.
 function scrolloffReveal(el, scroller, marginFrac) {
   if (!el || !scroller || !scroller.clientHeight) return;
   var top = el.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
@@ -655,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;
@@ -675,6 +708,22 @@ function next(delta) {
   // Every changed file is marked viewed — nothing left to review, so F7/[/] stay put.
 }
 
+// Jump to the first change of the next unviewed file after `path` (wrapping). Used right after marking a
+// file viewed: its diff body is now hidden, so staying would blank the content — we advance to the next
+// change instead. Returns false when every changed file is viewed (nothing to advance to).
+function gotoNextUnviewedFile(path) {
+  const total = hunkTotal();
+  if (total === 0) return false;
+  const start = firstHunkForPath(path);
+  let idx = (start >= 0 ? start : (current >= 0 ? current : 0)) + 1;
+  for (let step = 0; step < total; step++) {
+    const norm = ((idx % total) + total) % total;
+    if (!isFileViewed(hunkPathAt(norm) || '')) { setActive(norm); return true; }
+    idx += 1;
+  }
+  return false;
+}
+
 function initialHunkForNavigation(delta) {
   const openPath = document.getElementById('source-viewer')?.dataset.openPath || '';
   const sourceHunk = firstHunkForPath(openPath);
@@ -695,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() {
@@ -707,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;
   }
@@ -727,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') {
@@ -916,8 +996,10 @@ function focusTree(index) {
   if (rows.length === 0) return;
   treeFocusIndex = Math.max(0, Math.min(rows.length - 1, index));
   // Render the focus class AND scroll in the SAME frame. A fast key-repeat queues many ArrowDowns before a
-  // frame; moving the focus class instantly while the coalesced scroll lags makes the panel jump ~one
-  // viewport (~20 rows) at a time. Coalescing both keeps focus + scroll in lockstep so it scrolls smoothly.
+  // frame; moving the focus class instantly while the coalesced scroll lags makes the panel jump. Coalescing
+  // both keeps focus + scroll in lockstep, and scrolloffReveal scrolls ONLY when the focused row nears the
+  // top/bottom edge — a row moving inside the visible band must never drag the whole panel (revealAt did,
+  // re-centering on every move so even a mid-list row scrolled the sidebar).
   scheduleTreeFocus();
 }
 var treeFocusRaf = 0;
@@ -929,7 +1011,7 @@ function scheduleTreeFocus() {
     if (treeFocusIndex < 0 || treeFocusIndex >= rows.length) return;
     const el = rows[treeFocusIndex];
     document.querySelectorAll('.tree-focus').forEach((e) => { if (e !== el) e.classList.remove('tree-focus'); });
-    if (el) { el.classList.add('tree-focus'); revealAt(el, document.querySelector('.sidebar-scroll'), 0.42); }
+    if (el) { el.classList.add('tree-focus'); scrolloffReveal(el, document.querySelector('.sidebar-scroll'), 0.15); }
   });
 }
 
@@ -1053,9 +1135,11 @@ function handleTreeKey(event) {
 // owns focus AND the only caret, so global shortcuts stand down until Esc/close — we must not navigate a
 // panel the user can't even see behind the overlay (nor leave a second blinking caret in it).
 function isFloatingModalOpen() {
-  if (document.getElementById('mc-modal') || document.getElementById('mc-memo')) return true;
   var sm = document.getElementById('settings-modal');
-  return !!(sm && !sm.classList.contains('hidden'));
+  if (sm && !sm.classList.contains('hidden')) return true;
+  // 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();
 }
 document.addEventListener('keydown', (event) => {
   if (!quickOpen?.classList.contains('hidden')) {
@@ -1066,12 +1150,32 @@ document.addEventListener('keydown', (event) => {
     if (handleUsagesKey(event)) return;
   }
 
-  // Floating overlay open (merged / memo / settings): it captures keys until Esc. Don't run ANY global
-  // shortcut (Cmd+1, F7, Cmd+[/], Cmd+B, open-merged/memo, …) underneath — focus and the only caret belong
-  // to the overlay. Each overlay has its own Esc + editing handlers, so we simply stand down here.
+  // Dock controls fire regardless of focus (terminal / merged / memo) — they sit ABOVE the focus guard so
+  // they still work from inside a dock panel. Cmd/Ctrl+Shift+' maximizes the active dock; Cmd/Ctrl+Shift+/
+  // 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.altKey && event.code === 'Quote') {
+    event.preventDefault();
+    toggleDockMaximized();
+    return;
+  }
+  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.altKey && (event.code === 'KeyN' || event.key === 'n' || event.key === 'N')) {
+    event.preventDefault();
+    openMemoView();
+    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
@@ -1086,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();
@@ -1121,21 +1225,8 @@ document.addEventListener('keydown', (event) => {
     }
   }
 
-  // Merged comment views — see every saved comment of one kind at once + copy-all to paste into a prompt:
-  //   Cmd/Ctrl+Shift+/ ("?") = all questions, Cmd/Ctrl+Shift+. (">") = all change-requests.
-  // Match the PHYSICAL key (event.code) so macOS/IME/layout never swallows the combo; fires in any focus.
-  if ((event.metaKey || event.ctrlKey) && (event.code === 'Slash' || event.code === 'Period' || event.key === '?' || event.key === '>')) {
-    event.preventDefault();
-    openMergedView((event.code === 'Slash' || event.key === '?') ? 'q' : 'c');
-    return;
-  }
-  // Cmd/Ctrl+Shift+N opens/closes the prompt memo. Electron also routes this via the Review menu; in the
-  // browser/serve build (no menu) this keydown is the only path. Match the physical key so layout/IME never swallows it.
-  if ((event.metaKey || event.ctrlKey) && event.shiftKey && (event.code === 'KeyN' || event.key === 'n' || event.key === 'N')) {
-    event.preventDefault();
-    openMemoView();
-    return;
-  }
+  // (Merged views Cmd/Ctrl+Shift+/ +. and the memo Cmd/Ctrl+Shift+N are handled above the focus guard so
+  // they work from inside a dock too.)
   // "?" = question, ">" = change-request composer on the current line/selection (no modifier).
   if (!event.altKey && !event.metaKey && !event.ctrlKey && (event.key === '?' || event.key === '>')) {
     const ce = document.activeElement;
@@ -1160,7 +1251,12 @@ document.addEventListener('keydown', (event) => {
       }
       if (vp && currentFileSignature(vp)) {
         event.preventDefault();
-        setFileViewed(vp, !isFileViewed(vp));
+        const willView = !isFileViewed(vp);
+        setFileViewed(vp, willView);
+        // Marking viewed hides this file's diff body — don't strand the caret on the now-blank file.
+        // Auto-advance to the next unviewed change (the user's flow: mark viewed -> jump to next).
+        // Unmarking stays put. If every file is viewed, gotoNextUnviewedFile is a no-op.
+        if (willView) gotoNextUnviewedFile(vp);
         return;
       }
     }
@@ -1180,10 +1276,14 @@ 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; }
   }
+  // A non-Shift keystroke between the two Shifts cancels the pending double-Shift quick-open. Without this,
+  // "Shift → type something → Shift" within 300ms still popped the search, so it fired on nearly every other
+  // keystroke. Reset BEFORE the caret handlers below (they swallow arrows) so arrow keys break it too.
+  if (event.key !== 'Shift') { lastShiftAt = 0; lastShiftSide = 0; }
   if (treeFocusIndex >= 0 && handleTreeKey(event)) return;
   if (treeFocusIndex < 0 && !event.metaKey && !event.ctrlKey && !event.altKey && isSourceViewerVisible() && handleSourceCaretKey(event)) return;
   if (treeFocusIndex < 0 && !event.metaKey && !event.ctrlKey && !event.altKey && isDiffViewVisible() && handleDiffCaretKey(event)) return;
@@ -1207,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;
@@ -1227,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();
@@ -1296,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');
@@ -1304,8 +1404,12 @@ document.addEventListener('keydown', (event) => {
     // where they were reading. Shift+F7 — and any file with no hunk of its own — falls through to plain
     // prev/next-change navigation across the whole diff.
     if (delta > 0 && sourceViewer && !sourceViewer.classList.contains('hidden')) {
-      const sourceHunk = firstHunkForPath(sourceViewer.dataset.openPath || '');
-      if (sourceHunk >= 0) {
+      const sp = sourceViewer.dataset.openPath || '';
+      const sourceHunk = firstHunkForPath(sp);
+      // Enter the diff at the open file's own hunk — UNLESS it's already viewed. A viewed file's diff body
+      // is hidden (display:none), so landing on it blanks the content and F7 appears stuck; fall through to
+      // next() instead so we skip to an unviewed change.
+      if (sourceHunk >= 0 && !isFileViewed(sp)) {
         setActive(sourceHunk);
         return;
       }
@@ -1369,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');
@@ -1405,7 +1522,12 @@ if (!restored) {
   else openDefaultSourceFile();
 }
 initSourceTreeFolds();
-if (watchEnabled) setInterval(checkForLiveUpdate, 1500);
+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')) {
+  setInterval(checkForLiveUpdate, 1500);
+}
 window.addEventListener('beforeunload', saveUiState);
 
 // First render has painted — drop the boot overlay (it bridged the blank gap right after loadFile). Two
@@ -1436,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', () => {
@@ -1622,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
@@ -1793,11 +1919,51 @@ function moveDiffWord(dir, extend) {
   setDiffCursor(diffCursor.path, diffCursor.side, diffCursor.rowIndex, ncol, true);
   if (anchor) { diffSelectionAnchor = anchor; applyDiffSelection(); }
 }
+// Comment boxes are injected on the right(new) side, right after the line's row (see injectThreadRow /
+// renderDiffComments). Split-view rows align 1:1 by index, so the caret's row index on the new side finds
+// the adjacent box regardless of which side the caret sits on. Mirrors commentRowSiblingOf for the source view.
+function diffCommentBoxSiblingOf(dir) {
+  if (!diffCursor) return null;
+  var wrapper = diffWrapperByPath(diffCursor.path);
+  if (!wrapper) return null;
+  var rows = diffRowsOf(diffSideTable(wrapper, 'new'));
+  var row = rows[diffCursor.rowIndex];
+  if (!row) return null;
+  var sib = dir < 0 ? row.previousElementSibling : row.nextElementSibling;
+  return (sib && sib.classList && sib.classList.contains('mc-comment-row')) ? sib : null;
+}
 function handleDiffCaretKey(event) {
   if (!isDiffViewVisible() || !diffCursor) return false;
   var ae = document.activeElement;
   if (ae && (ae.tagName === 'INPUT' || ae.tagName === 'TEXTAREA' || ae.tagName === 'SELECT')) return false;
   var extend = event.shiftKey;
+  // A comment box is selected: Backspace/Delete removes it, `e` edits it, an arrow/Escape steps off it.
+  // Same contract as the source view (handleSourceCaretKey), but caret moves go through setDiffCursor.
+  if (selectedCommentRow) {
+    if (event.key === 'Backspace' || event.key === 'Delete') { event.preventDefault(); deleteCommentsInRow(selectedCommentRow); return true; }
+    if (event.key === 'e' || event.key === 'E') { event.preventDefault(); editCommentInRow(selectedCommentRow); return true; }
+    if (event.key === 'ArrowUp' || event.key === 'ArrowDown' || event.key === 'ArrowLeft' || event.key === 'ArrowRight' || event.key === 'Escape') {
+      var dir = event.key === 'ArrowUp' ? -1 : (event.key === 'ArrowDown' ? 1 : 0);
+      var sib = dir < 0 ? selectedCommentRow.previousElementSibling : (dir > 0 ? selectedCommentRow.nextElementSibling : null);
+      selectedCommentRow.classList.remove('mc-row-selected');
+      selectedCommentRow = null;
+      event.preventDefault();
+      var wrapper = diffWrapperByPath(diffCursor.path);
+      if (sib && wrapper && isDiffCodeRow(sib)) {
+        var rows = diffRowsOf(diffSideTable(wrapper, 'new'));
+        var idx = rows.indexOf(sib);
+        if (idx >= 0) { setDiffCursor(diffCursor.path, 'new', idx, 0, true); return true; }
+      }
+      setDiffCursor(diffCursor.path, diffCursor.side, diffCursor.rowIndex, diffCursor.column, false); // restore caret where it was
+      return true;
+    }
+    return false;
+  }
+  // Plain Up/Down: a comment box attached to the caret line is a selectable stop (caret stays visible).
+  if (!extend && (event.key === 'ArrowUp' || event.key === 'ArrowDown')) {
+    var box = diffCommentBoxSiblingOf(event.key === 'ArrowUp' ? -1 : 1);
+    if (box) { event.preventDefault(); selectCommentRow(box); return true; }
+  }
   if (event.key === 'ArrowDown') { event.preventDefault(); moveDiffCursor(1, 0, extend); return true; }
   if (event.key === 'ArrowUp') { event.preventDefault(); moveDiffCursor(-1, 0, extend); return true; }
   if (event.key === 'ArrowLeft') { event.preventDefault(); moveDiffCursor(0, -1, extend); return true; }
@@ -1822,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
@@ -2127,6 +2315,7 @@ function closeComposer() {
   if (!composerState) return;
   composerState = null;
   refreshComments();
+  flushPendingDiffUpdate(); // apply any live watch refresh that was held while composing
 }
 // The composer is injected into BOTH the diff and source views (refreshComments renders comments in
 // each), but only one view is on screen at a time — the other lives inside a `.hidden` container with
@@ -2151,6 +2340,7 @@ function saveComposer(ta) {
   else addComment(composerState.kind, composerState.path, composerState.line, composerState.code, box.value);
   composerState = null;
   refreshComments();
+  flushPendingDiffUpdate(); // apply any live watch refresh that was held while composing
 }
 
 // Default merge-prompt headings, localized: a Korean user gets Korean defaults. Editable in
@@ -2292,36 +2482,153 @@ function buildMergedText(kind) {
   return lines.join(nl);
 }
 
-function openMergedView(kind) {
-  var existing = document.getElementById('mc-modal');
-  if (existing) existing.remove();
-  var modal = document.createElement('div');
-  modal.id = 'mc-modal';
-  modal.className = 'mc-modal';
-  modal.dataset.kind = kind; // remembered so a live locale switch can re-render this same view
+// ===== Bottom dock: merged-prompt / memo / terminal share ONE docked slot below the editor =====
+// Only one is visible at a time — opening one closes the others (the terminal included). Cmd/Ctrl+Shift+'
+// maximizes the active dock over the editor area (the sidebar stays). A top resizer drags the height.
+var dockHeightKey = 'monacori-dock-height';
+var dockMaximized = false;
+function applyDockHeight(px) {
+  var h = Math.max(140, Math.min(px, window.innerHeight - 120));
+  document.documentElement.style.setProperty('--dock-height', h + 'px');
+}
+(function () { var s = parseInt(localStorage.getItem(dockHeightKey) || '', 10); if (s) applyDockHeight(s); })();
+// The dock panel currently filling the slot: a merged/memo panel, else the terminal when it's open.
+function activeDockPanel() {
+  var mm = document.getElementById('mc-merged-panel') || document.getElementById('mc-memo-panel');
+  if (mm) return mm;
+  var term = document.getElementById('terminal-panel');
+  return (term && !term.classList.contains('hidden')) ? term : null;
+}
+function applyDockMaximized() {
+  if (!activeDockPanel()) dockMaximized = false; // nothing docked -> can't stay maximized
+  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();
+}
+function isDockFocused() {
+  var ae = document.activeElement;
+  return !!(ae && ae.closest && ae.closest('.dock-panel'));
+}
+// Close the merged/memo docks (the terminal's setOpen also calls this so the slot stays exclusive).
+function closeMergedMemoDocks() {
+  var m = document.getElementById('mc-merged-panel'); if (m) m.remove();
+  var n = document.getElementById('mc-memo-panel'); if (n) n.remove();
+  document.querySelectorAll('.dock-backdrop').forEach(function (b) { b.remove(); });
+  document.body.classList.toggle('dock-open', !!activeDockPanel());
+  // floating-dock tracks merged/memo only (NOT the terminal) so the maximize CSS hides content for a
+  // 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).
+function focusDockField(field, panelSel) {
+  var tries = 0;
+  var tryF = function () {
+    if (!document.querySelector(panelSel)) return true;
+    if (document.activeElement === field) return true;
+    try { field.focus(); } catch (e) {}
+    return document.activeElement === field;
+  };
+  if (!tryF()) { var iv = setInterval(function () { if (tryF() || ++tries > 12) clearInterval(iv); }, 25); }
+}
+// Build a docked panel shell (resizer + bar with Maximize/Close + body) and mount it below the editor.
+// Opening it closes the terminal and any other merged/memo dock (the slot is exclusive). Returns
+// { panel, body, bar, close }.
+function mountDock(id, titleText) {
+  if (window.__monacoriTerminal && typeof window.__monacoriTerminal.close === 'function') {
+    try { window.__monacoriTerminal.close(); } catch (e) {}
+  }
+  var prior = document.getElementById(id);
+  if (prior) prior.remove();
+  closeMergedMemoDocks();
   var panel = document.createElement('div');
-  panel.className = 'mc-modal-panel';
-  var head = document.createElement('div');
-  head.className = 'mc-modal-head';
+  panel.id = id;
+  panel.className = 'dock-panel';
+  panel.tabIndex = -1;
+  // The panel floats over the editor; a dim backdrop sits behind it (click to dismiss).
+  var backdrop = document.createElement('div');
+  backdrop.className = 'dock-backdrop';
+  var resizer = document.createElement('div');
+  resizer.className = 'dock-resizer';
+  resizer.setAttribute('aria-hidden', 'true');
+  var bar = document.createElement('div');
+  bar.className = 'dock-bar';
   var title = document.createElement('span');
-  title.textContent = kind === 'q' ? t('merged.qTitle') : t('merged.cTitle');
+  title.className = 'dock-title';
+  title.textContent = titleText;
+  var maxBtn = document.createElement('button');
+  maxBtn.type = 'button';
+  maxBtn.className = 'dock-btn dock-max';
+  maxBtn.setAttribute('data-i18n-title', 'dock.maximize');
+  maxBtn.title = t('dock.maximize');
+  maxBtn.textContent = '⤢'; // ⤢ maximize glyph
   var closeBtn = document.createElement('button');
   closeBtn.type = 'button';
-  closeBtn.className = 'mc-btn mc-ghost';
+  closeBtn.className = 'dock-btn dock-close';
+  closeBtn.setAttribute('data-i18n', 'merged.close');
   closeBtn.textContent = t('merged.close');
+  var body = document.createElement('div');
+  body.className = 'dock-body';
+  bar.appendChild(title);
+  bar.appendChild(maxBtn);
+  bar.appendChild(closeBtn);
+  panel.appendChild(resizer);
+  panel.appendChild(bar);
+  panel.appendChild(body);
+  document.body.appendChild(backdrop);
+  document.body.appendChild(panel);
+  function close() { panel.remove(); backdrop.remove(); closeMergedMemoDocks(); }
+  maxBtn.addEventListener('click', function () { toggleDockMaximized(); });
+  closeBtn.addEventListener('click', close);
+  backdrop.addEventListener('click', close); // click the dim behind the panel to dismiss
+  // Esc closes the dock when focus is inside it; the editor keeps its own handlers otherwise.
+  panel.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); }
+  });
+  resizer.addEventListener('mousedown', function (e) {
+    e.preventDefault();
+    resizer.classList.add('resizing');
+    function move(ev) { applyDockHeight(window.innerHeight - ev.clientY); }
+    function up() {
+      resizer.classList.remove('resizing');
+      document.removeEventListener('mousemove', move);
+      document.removeEventListener('mouseup', up);
+      var cur = parseInt(getComputedStyle(document.documentElement).getPropertyValue('--dock-height'), 10);
+      if (cur) { try { localStorage.setItem(dockHeightKey, String(cur)); } catch (x) {} }
+    }
+    document.addEventListener('mousemove', move);
+    document.addEventListener('mouseup', up);
+  });
+  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 };
+}
+
+function openMergedView(kind) {
+  var dock = mountDock('mc-merged-panel', kind === 'q' ? t('merged.qTitle') : t('merged.cTitle'));
+  dock.panel.dataset.kind = kind; // remembered so a live locale switch can re-render this same view
   var area = document.createElement('textarea');
   area.className = 'mc-modal-text';
   // NOT readOnly: a readOnly textarea hides the caret in Chromium, yet we need it VISIBLE so the user sees
-  // which comment Opt+Enter / Opt+Arrow will target. Block every edit via beforeinput instead — read-only in
-  // effect while the caret and selection stay fully interactive.
+  // which comment Opt+Enter / Opt+Arrow will target. Block every edit via beforeinput instead.
   area.value = buildMergedText(kind);
   area.addEventListener('beforeinput', function (e) { e.preventDefault(); });
-  // Opt/Alt+Enter on the merged text: a custom dropdown for the comment under the caret — "Go to comment"
-  // + "Remove" for a single caret; "Remove" only for a drag/select-all (can't navigate to many at once).
-  // Removing here calls deleteComment(), which re-syncs the on-screen comment boxes via refreshComments.
+  // Opt/Alt+Enter on the merged text: a custom dropdown for the comment under the caret. Opt/Alt+Arrow steps
+  // the caret comment-to-comment so each can be acted on without hand-scrolling.
   area.addEventListener('keydown', function (e) {
-    // Opt/Alt + Arrow steps the caret to the next/previous comment block so you can move comment-to-comment
-    // and act on each with Opt+Enter, without hand-scrolling.
     if (e.altKey && (e.key === 'ArrowDown' || e.key === 'ArrowUp')) {
       e.preventDefault();
       e.stopPropagation();
@@ -2336,49 +2643,28 @@ function openMergedView(kind) {
     var cxy = mergedCaretXY(area);
     var x = cxy.x, y = cxy.below, flipTop = cxy.top;
     var rerender = function () {
-      if (!reviewComments.filter(function (c) { return c.kind === kind; }).length) { modal.remove(); return; }
+      if (!reviewComments.filter(function (c) { return c.kind === kind; }).length) { dock.close(); return; }
       area.value = buildMergedText(kind);
     };
     if (area.selectionStart !== area.selectionEnd || seqs.length > 1) {
       // Select-all / multi-comment: offer send-to-terminal (the whole merged text) FIRST, then remove-all.
-      // Can't "Go to comment" across many at once, so navigate is omitted here.
       var multi = [];
-      if (window.__monacoriTerminal && typeof window.__monacoriTerminal.isOpen === 'function' && window.__monacoriTerminal.isOpen()) {
-        multi.push({ label: t('merged.sendToTerminal'), onSelect: function () { var text = buildMergedText(kind); modal.remove(); window.__monacoriTerminal.enterSendMode(text); } });
+      if (window.__monacoriTerminal && typeof window.__monacoriTerminal.paneCount === 'function' && window.__monacoriTerminal.paneCount() > 0) {
+        multi.push({ label: t('merged.sendToTerminal'), onSelect: function () { var text = buildMergedText(kind); dock.close(); window.__monacoriTerminal.enterSendMode(text); } });
       }
       multi.push({ label: t('dropdown.remove'), onSelect: function () { seqs.forEach(deleteComment); rerender(); } });
       showCustomDropdown(x, y, multi, flipTop);
     } else {
       var seq = seqs[0];
       showCustomDropdown(x, y, [
-        { label: t('dropdown.navigate'), onSelect: function () { modal.remove(); navigateToComment(seq); } },
+        { label: t('dropdown.navigate'), onSelect: function () { dock.close(); navigateToComment(seq); } },
         { label: t('dropdown.remove'), onSelect: function () { deleteComment(seq); rerender(); } },
       ], flipTop);
     }
   });
-  closeBtn.addEventListener('click', function () { modal.remove(); });
-  // Send-to-terminal now lives in the Opt+Enter dropdown (select-all -> first item), not as a header button.
-  head.appendChild(title);
-  head.appendChild(closeBtn);
-  panel.appendChild(head);
-  panel.appendChild(area);
-  modal.appendChild(panel);
-  modal.addEventListener('mousedown', function (e) { if (e.target === modal) modal.remove(); });
-  modal.addEventListener('keydown', function (e) { if (e.key === 'Escape') { e.preventDefault(); modal.remove(); } });
-  document.body.appendChild(modal);
-  // Focus the read-only text so the caret is visible and Opt+Arrow / Opt+Enter (incl. the send-to-terminal
-  // dropdown item) work. Electron async-restores focus to <body>, so retry briefly (same as the composer).
-  var modalFocusTarget = area;
-  var modalFocusTries = 0;
-  var tryFocusModal = function () {
-    if (!document.getElementById('mc-modal')) return true;
-    if (document.activeElement === modalFocusTarget) return true;
-    try { modalFocusTarget.focus(); modalFocusTarget.selectionStart = modalFocusTarget.selectionEnd = 0; } catch (e) {}
-    return document.activeElement === modalFocusTarget;
-  };
-  if (!tryFocusModal()) {
-    var modalFocusIv = setInterval(function () { if (tryFocusModal() || ++modalFocusTries > 12) clearInterval(modalFocusIv); }, 25);
-  }
+  dock.body.appendChild(area);
+  // Focus the read-only text so the caret is visible and Opt+Arrow / Opt+Enter work; retry (Electron focus race).
+  focusDockField(area, '#mc-merged-panel');
 }
 
 // Prompt memo (Cmd/Ctrl+Shift+N): one freeform Markdown scratchpad with a live split preview, persisted
@@ -2396,27 +2682,10 @@ function renderMemoMd(text) {
   return renderMarkdownBlocks(text).map(function (b) { return b.html; }).join('');
 }
 function openMemoView() {
-  var existing = document.getElementById('mc-memo');
-  if (existing) { existing.remove(); return; } // the shortcut toggles: a second press closes the memo
-  var modal = document.createElement('div');
-  modal.id = 'mc-memo';
-  modal.className = 'mc-modal';
-  var panel = document.createElement('div');
-  panel.className = 'mc-modal-panel mc-memo-panel';
-  var head = document.createElement('div');
-  head.className = 'mc-modal-head';
-  var title = document.createElement('span');
-  title.setAttribute('data-i18n', 'memo.title');
-  title.textContent = t('memo.title');
-  var closeBtn = document.createElement('button');
-  closeBtn.type = 'button';
-  closeBtn.className = 'mc-btn mc-ghost';
-  closeBtn.setAttribute('data-i18n', 'merged.close');
-  closeBtn.textContent = t('merged.close');
-  closeBtn.addEventListener('click', function () { modal.remove(); });
-
-  var body = document.createElement('div');
-  body.className = 'mc-memo-body';
+  if (document.getElementById('mc-memo-panel')) { closeMergedMemoDocks(); return; } // the shortcut toggles: 2nd press closes
+  var dock = mountDock('mc-memo-panel', t('memo.title'));
+  var memoBody = document.createElement('div');
+  memoBody.className = 'mc-memo-body';
   var area = document.createElement('textarea');
   area.className = 'mc-modal-text mc-memo-edit';
   area.spellcheck = false;
@@ -2430,45 +2699,25 @@ function openMemoView() {
     saveMemo(area.value);
     preview.innerHTML = renderMemoMd(area.value);
   });
-
-  // Terminal send: hand the current draft to pane-pick mode (arrows choose the session, Enter sends). Shown
-  // only once a terminal pane exists; enterSendMode reopens the panel if it was closed.
-  var sendBtn = null;
+  // Terminal send: hand the current draft to pane-pick mode. Shown only once a terminal pane exists;
+  // enterSendMode reopens the terminal (which closes this memo dock — the slot is exclusive).
   if (window.__monacoriTerminal && typeof window.__monacoriTerminal.paneCount === 'function' && window.__monacoriTerminal.paneCount() > 0) {
-    sendBtn = document.createElement('button');
+    var sendBtn = document.createElement('button');
     sendBtn.type = 'button';
-    sendBtn.className = 'mc-btn mc-send-term';
+    sendBtn.className = 'dock-btn mc-send-term';
     sendBtn.setAttribute('data-i18n', 'merged.sendToTerminal');
     sendBtn.textContent = t('merged.sendToTerminal');
     sendBtn.addEventListener('click', function () {
       var text = area.value;
-      modal.remove();
+      dock.close();
       window.__monacoriTerminal.enterSendMode(text);
     });
+    dock.bar.insertBefore(sendBtn, dock.bar.querySelector('.dock-max'));
   }
-
-  head.appendChild(title);
-  if (sendBtn) head.appendChild(sendBtn);
-  head.appendChild(closeBtn);
-  body.appendChild(area);
-  body.appendChild(preview);
-  panel.appendChild(head);
-  panel.appendChild(body);
-  modal.appendChild(panel);
-  modal.addEventListener('mousedown', function (e) { if (e.target === modal) modal.remove(); });
-  modal.addEventListener('keydown', function (e) { if (e.key === 'Escape') { e.preventDefault(); modal.remove(); } });
-  document.body.appendChild(modal);
-  // Focus the editor; Electron async-restores focus to <body>, so retry briefly (same as the composer/merged view).
-  var memoFocusTries = 0;
-  var tryFocusMemo = function () {
-    if (!document.getElementById('mc-memo')) return true;
-    if (document.activeElement === area) return true;
-    try { area.focus(); } catch (e) {}
-    return document.activeElement === area;
-  };
-  if (!tryFocusMemo()) {
-    var memoFocusIv = setInterval(function () { if (tryFocusMemo() || ++memoFocusTries > 12) clearInterval(memoFocusIv); }, 25);
-  }
+  memoBody.appendChild(area);
+  memoBody.appendChild(preview);
+  dock.body.appendChild(memoBody);
+  focusDockField(area, '#mc-memo-panel');
 }
 
 document.addEventListener('click', function (event) {
@@ -2539,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.
@@ -2552,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');
@@ -2587,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;
@@ -2594,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);
@@ -2641,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);
@@ -2652,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;
@@ -2674,10 +2951,13 @@ refreshComments();
 
   function isOpen() { return !panel.classList.contains('hidden'); }
   function setOpen(open) {
+    // The terminal shares the bottom dock slot with merged/memo — opening it closes those (exclusive slot).
+    if (open && typeof window.__monacoriCloseDocks === 'function') { try { window.__monacoriCloseDocks(); } catch (e) {} }
     panel.classList.toggle('hidden', !open);
     document.body.classList.toggle('terminal-open', open);
     if (toggleBtn) toggleBtn.classList.toggle('is-active', open);
     try { sessionStorage.setItem(openKey, open ? '1' : '0'); } catch (e) {}
+    if (typeof applyDockMaximized === 'function') applyDockMaximized(); // keep Cmd+Shift+' maximize in sync
     if (open) {
       if (panes.length === 0) makePane();
       requestAnimationFrame(function () { fitAll(); if (active) try { active.term.focus(); } catch (e) {} });
@@ -2782,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); },
@@ -2811,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();
   });
 }
@@ -2925,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',
@@ -2958,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.
@@ -3053,8 +3367,19 @@ function restoreUiState() {
 // regions (diff container, sidebar trees, status, data) and re-run the bootstrap steps. The window never
 // reloads, so the integrated terminal's pty sessions (claude/codex) survive a watch refresh. Electron's
 // main pushes the payload over IPC (monacori:diff-update); serve mode's poller fetches /__ai_flow_update.
+// Live watch refreshes are HELD while a comment composer is open. applyDiffUpdate rebuilds the diff DOM, so
+// applying it mid-compose would destroy the composer textarea every watch tick — input stalls and characters
+// arrive in bursts — and flicker the page. Keep only the latest pending payload; flush it on close/save.
+var pendingDiffUpdate = null;
+function flushPendingDiffUpdate() {
+  if (!pendingDiffUpdate) return;
+  var u = pendingDiffUpdate;
+  pendingDiffUpdate = null;
+  try { applyDiffUpdate(u); } catch (e) {}
+}
 function applyDiffUpdate(u) {
   if (!u || !u.signature || u.signature === currentSignature) return false; // unchanged — nothing to do
+  if (composerState) { pendingDiffUpdate = u; return false; } // composing a comment — hold the refresh until close/save
 
   // Remember what to restore after the swap (comments/viewed persist on their own; these don't).
   var sv = document.getElementById('source-viewer');
@@ -3062,11 +3387,28 @@ 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.
   var prevOpenSig = openPath ? (fileSignatureByPath.get(openPath) || '') : '';
 
+  // Snapshot already-materialized file bodies (keyed by path + current signature) BEFORE the swap, so an
+  // UNCHANGED file can be re-filled synchronously afterwards. Without this, the swap turns every wrapper into
+  // an empty lazy shell that blanks until its body re-loads over IPC — the visible "flicker" on a watch tick.
+  var prevBodies = {};
+  if (REVIEW_LAZY && container) {
+    container.querySelectorAll('.d2h-file-wrapper').forEach(function (w) {
+      var b = w.querySelector('.d2h-files-diff');
+      if (!b || b.hasAttribute('data-lazy')) return; // only bodies that are actually materialized
+      var p = diffWrapperPathKey(w);
+      if (p) prevBodies[p] = { sig: fileSignatureByPath.get(p) || '', html: b.innerHTML };
+    });
+  }
+
   // 1) Replace the visible regions straight from the payload (no full-HTML parse).
   if (container) container.innerHTML = u.diffContainer || '';
   var changesPanel = document.getElementById('changes-panel');
@@ -3079,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.
@@ -3095,7 +3444,21 @@ 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
+  // OLD body, so a watch change never showed up in the diff until a full reload.
+  bodyCache = {};
   bodyPromise = {};
   diffBootDone = false;
   sourceLoaded = !REVIEW_LAZY_LOAD; // lazyLoad: re-fetch source content on next use
@@ -3104,8 +3467,27 @@ function applyDiffUpdate(u) {
   // sourceBodyPath so the already-painted (unchanged) source view is left exactly as-is — no flicker.
   if (openFileChanged) sourceBodyPath = null;
   symbolIndex = null;
+
+  // 3b) Re-fill UNCHANGED files' bodies synchronously from the snapshot so they don't blank-then-reload (the
+  // 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);
+      var prev = p ? prevBodies[p] : null;
+      if (!prev || !prev.sig || prev.sig !== (fileSignatureByPath.get(p) || '')) return; // changed/new -> lazy-load
+      var shell = w.querySelector('.d2h-files-diff[data-lazy]');
+      if (!shell) return;
+      var idx = (w.id || '').replace('file-', '');
+      materializeBody(w, prev.html);           // fills the body + markWrapperHunks (uses the new data-first-hunk)
+      bodyCache[idx] = prev.html;              // keep the index cache consistent so it never refetches
+      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 { prepareDiff2HtmlHunks(); diffBootDone = true; }
+  else { diffBootDone = true; }
   if (!REVIEW_LAZY_LOAD) setTimeout(startSymbolIndex, 0);
 
   // 4) Re-run the DOM-dependent bootstrap steps.
@@ -3121,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;
 }
@@ -3770,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');
@@ -3807,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
@@ -3985,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);
@@ -4462,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>'