@happy-nut/monacori 0.1.19 → 0.1.21

package/dist/viewer.client.js

@@ -98,14 +98,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
@@ -319,7 +324,6 @@ function prepareDiff2HtmlHunks() {
 prepareViewedControls();
 
 function prepareViewedControls() {
-  pruneViewedState();
   document.querySelectorAll('.d2h-file-wrapper').forEach((wrapper) => {
     const fileName = wrapper.querySelector('.d2h-file-name')?.textContent?.trim() || '';
     const toggle = wrapper.querySelector('.d2h-file-collapse');
@@ -356,34 +360,23 @@ function currentFileSignature(path) {
 
 function isFileViewed(path) {
   const viewed = loadViewedState();
-  const signature = currentFileSignature(path);
-  return Boolean(signature && viewed[path] === signature);
+  return Boolean(viewed[path]); // boolean now; legacy signature strings are also truthy, so old marks still read as viewed
 }
 
 function setFileViewed(path, viewed) {
   const state = loadViewedState();
-  if (viewed) {
-    const signature = currentFileSignature(path);
-    if (signature) state[path] = signature;
-  } else {
-    delete state[path];
-  }
+  // Persist a plain boolean (not the file signature) so a viewed mark survives a restart/refresh the way
+  // comments do. Tying it to the signature meant any re-generation that changed the signature silently
+  // cleared every viewed mark — exactly the "viewed didn't persist" the user hit.
+  if (viewed) state[path] = true;
+  else delete state[path];
   saveViewedState(state);
   applyViewedState();
 }
 
-function pruneViewedState() {
-  const state = loadViewedState();
-  let changed = false;
-  Object.keys(state).forEach((path) => {
-    if (state[path] !== currentFileSignature(path)) {
-      delete state[path];
-      changed = true;
-    }
-  });
-  if (changed) saveViewedState(state);
-}
-
+// Viewed marks persist by path (a plain boolean), like comments — we deliberately DON'T prune on signature
+// change or restart. Tying persistence to the file signature is what made viewed marks vanish on every
+// re-generation; the user wants them to survive restarts the way comments do.
 function applyViewedState() {
   document.querySelectorAll('.d2h-file-wrapper').forEach((wrapper) => {
     const fileName = wrapper.querySelector('.d2h-file-name')?.textContent?.trim() || '';
@@ -518,6 +511,18 @@ function revealAt(el, scroller, fraction) {
   var off = el.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
   scroller.scrollTop += off - scroller.clientHeight * 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 and the sidebar tree.
+function scrolloffReveal(el, scroller, marginFrac) {
+  if (!el || !scroller || !scroller.clientHeight) return;
+  var top = el.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
+  var rowH = el.offsetHeight || 18;
+  var ch = scroller.clientHeight;
+  var margin = Math.round(ch * marginFrac);
+  if (top < margin) scroller.scrollTop += top - margin;
+  else if (top + rowH > ch - margin) scroller.scrollTop += (top + rowH) - (ch - margin);
+}
 function scheduleScrollIntoView(el) {
   pendingScrollEl = el || null;
   if (scrollElRaf) return;
@@ -557,7 +562,7 @@ function applySetActive(idx, shouldScroll) {
   history.replaceState(null, '', '#hunk-' + idx);
   // Row-dependent work waits for the file body (sync for eager/Phase 1, async for cold lazy-LOAD).
   whenFileReady(diffWrapperByPath(file), function () {
-    showOnlyFile(file);
+    showOnlyFile(file, true); // materialize + isolate the file, but leave the caret to focusDiffRow (skip ensureDiffCursor)
     const active = document.getElementById('hunk-' + idx);
     if (!active) return;
     if (REVIEW_LAZY) {
@@ -571,16 +576,24 @@ function applySetActive(idx, shouldScroll) {
     // F7/change navigation moves the caret but must NOT pollute the Cmd+[/] cursor history.
     navSuppress = true;
     try { focusDiffRow(targetRow); } finally { navSuppress = false; }
-    if (shouldScroll && targetRow) scheduleDiffScroll(targetRow);
+    // Scroll inline in THIS frame, NOT via scheduleDiffScroll's extra rAF. showOnlyFile just display:none'd
+    // the previous file, but the scroll container keeps its old (larger) scrollTop — so for one frame the new
+    // file renders at that stale offset (≈ line 146) before a deferred scroll snaps to the change (≈ line 21):
+    // the visible 146→21 double jump on F7 across a file boundary. Scrolling synchronously here lands the
+    // view on the change before this frame paints, so the new file appears already at its first change.
+    if (shouldScroll && targetRow && targetRow.scrollIntoView) targetRow.scrollIntoView({ block: 'center' });
   });
 }
 
-function showOnlyFile(fileName) {
+function showOnlyFile(fileName, skipCursor) {
   if (REVIEW_LAZY) ensureFileReady(diffWrapperByPath(fileName));
   document.querySelectorAll('.d2h-file-wrapper').forEach((wrapper) => {
     wrapper.classList.toggle('df-inactive', diffWrapperPathKey(wrapper) !== fileName);
   });
-  ensureDiffCursor();
+  // applySetActive passes skipCursor: it sets the caret itself via focusDiffRow(targetRow). Letting
+  // ensureDiffCursor run here would first place the caret on the file's FIRST code row, then focusDiffRow
+  // overrides it to the change — a visible double jump (the F7 "first line → change" flash).
+  if (!skipCursor) ensureDiffCursor();
 }
 
 // The hunk the diff caret currently sits in. Arrow keys move the caret without touching the active
@@ -622,6 +635,10 @@ function changeBlockAnchors(wrapper) {
   return anchors;
 }
 
+// Forward F7 at a file's last change announces "last change — press F7 again" once before crossing to the
+// next file, giving a beat to mark-viewed. Holds the path we've already announced; any caret move clears it
+// (see setDiffCursor), so leaving and returning to the last change re-arms the announcement.
+var pendingFileBoundary = null;
 function next(delta) {
   if (hunkTotal() === 0) return;
   // Within the caret's (unviewed) file, step change-block by change-block so a context-merged hunk
@@ -640,7 +657,18 @@ function next(delta) {
       }
     }
   }
-  // File boundary (no more change blocks this file) → hunk-level nav to the next/prev unviewed file.
+  // 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)) {
+    if (pendingFileBoundary !== diffCursor.path) {
+      pendingFileBoundary = diffCursor.path;
+      showToast(t('diff.lastHunk'));
+      return;
+    }
+    pendingFileBoundary = null; // second consecutive press on the same file → fall through and cross
+  }
+  // hunk-level nav to the next/prev unviewed file.
   const caretHunk = hunkIndexAtCaret();
   const base = caretHunk >= 0 ? caretHunk : current;
   let idx = base < 0 ? initialHunkForNavigation(delta) : base + delta;
@@ -652,6 +680,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);
@@ -893,8 +937,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;
@@ -906,7 +952,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); }
   });
 }
 
@@ -1026,6 +1072,16 @@ function handleTreeKey(event) {
     if (Math.abs(e.deltaY) >= Math.abs(e.deltaX) && e.deltaY !== 0) { dsc.scrollTop += e.deltaY; e.preventDefault(); }
   }, { passive: false });
 })();
+// A floating, focus-grabbing overlay (merged-comments, prompt memo, settings) is open. While one is up it
+// 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() {
+  var sm = document.getElementById('settings-modal');
+  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')) {
     if (handleQuickOpenKey(event)) return;
@@ -1035,8 +1091,42 @@ document.addEventListener('keydown', (event) => {
     if (handleUsagesKey(event)) return;
   }
 
+  // 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.code === 'Quote') {
+    event.preventDefault();
+    toggleDockMaximized();
+    return;
+  }
+  if (!settingsUp && (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;
+  }
+  if (!settingsUp && (event.metaKey || event.ctrlKey) && event.shiftKey && (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') {
     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
+    // the view (isDiffViewVisible would then be false).
+    if (isDiffViewVisible()) {
+      var dw1 = diffActiveWrapper();
+      var dn1 = dw1 && dw1.querySelector('.d2h-file-name');
+      var dpath1 = (diffCursor && diffCursor.path) || (dn1 ? (dn1.textContent || '').trim() : '');
+      if (dpath1 && sourceByPath.has(dpath1)) openSourceFile(dpath1);
+    }
     setTab('files');
     focusOpenFileInTree();
     return;
@@ -1076,21 +1166,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;
@@ -1115,7 +1192,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;
       }
     }
@@ -1139,6 +1221,10 @@ document.addEventListener('keydown', (event) => {
     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;
@@ -1259,8 +1345,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;
       }
@@ -1360,7 +1450,11 @@ if (!restored) {
   else openDefaultSourceFile();
 }
 initSourceTreeFolds();
-if (watchEnabled) setInterval(checkForLiveUpdate, 1500);
+// 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
@@ -1542,9 +1636,17 @@ function renderDiffCaret() {
   row.classList.add('mc-diff-cursor-row');
   var ctn = diffCellCtn(row);
   if (!ctn) return;
-  // Empty line (ctn is just a <br>): the row highlight marks the caret. Inserting a caret span
-  // next to the <br> would push it onto a second visual line and break the row's height.
-  if ((ctn.textContent || '').length === 0) return;
+  // Empty line (ctn is just a <br>): an inline caret span would wrap onto a 2nd visual line and break the
+  // row height, so position the caret absolutely — it shows without affecting the layout.
+  if ((ctn.textContent || '').length === 0) {
+    var espan = document.createElement('span');
+    espan.className = 'code-cursor';
+    espan.setAttribute('aria-hidden', 'true');
+    espan.style.position = 'absolute';
+    ctn.appendChild(espan);
+    diffCaretSpan = espan;
+    return;
+  }
   var pos = diffCaretDomPosition(ctn, diffCursor.column);
   if (!pos) return;
   var span = document.createElement('span');
@@ -1568,6 +1670,7 @@ function setDiffCursor(path, side, rowIndex, column, reveal) {
   var ri = Math.max(0, Math.min(rowIndex, rows.length - 1));
   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)
   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
@@ -1592,7 +1695,7 @@ function scheduleDiffReveal(wrapper, side, ri) {
     applyDiffSelection();
     if (!t) return;
     var row = diffRowAt(t.wrapper, t.side, t.ri);
-    revealAt(row, document.getElementById('diff2html-container'), 0.42);
+    scrolloffReveal(row, document.getElementById('diff2html-container'), 0.15);
   });
 }
 function navEntryOf(kind) {
@@ -1739,11 +1842,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; }
@@ -1768,35 +1911,30 @@ function showToast(message) {
     setTimeout(function () { if (el.parentNode) el.parentNode.removeChild(el); }, 300);
   }, 4500);
 }
-// When a file changes, follow each comment to its snapshot line (c.code) in the new content: same line if
-// unchanged, else the nearest exact match of that line. If the line can't be found the change is too large
-// to trust — drop the comment and toast. Files whose content isn't loaded yet (lazy) are skipped here and
-// reconciled once loadSourceData brings the content in.
+// 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
+// diff line (comments carry no side, so old-side text never matches the new content) would otherwise vanish.
+// Silently dropping user-authored comments loses data; the reviewer can remove a stale one with the × button.
+// Files whose content isn't loaded yet (lazy) are skipped here and reconciled once loadSourceData arrives.
 function remapComments() {
   if (!reviewComments.length) return;
-  var dropped = [], moved = 0;
-  reviewComments = reviewComments.filter(function (c) {
+  var moved = 0;
+  reviewComments.forEach(function (c) {
     var file = sourceByPath.get(c.path);
-    if (!file || !file.embedded || typeof file.content !== 'string' || !file.content) return true;
+    if (!file || !file.embedded || typeof file.content !== 'string' || !file.content) return;
     var code = c.code == null ? '' : String(c.code);
-    if (!code.trim()) return true;
+    if (!code.trim()) return;
     var lines = file.content.split(/\r?\n/);
-    if (lines[c.line - 1] === code) return true;
+    if (lines[c.line - 1] === code) return;
     var best = -1, bestDist = Infinity;
     for (var i = 0; i < lines.length; i++) {
       if (lines[i] === code) { var d = Math.abs(i - (c.line - 1)); if (d < bestDist) { bestDist = d; best = i; } }
     }
-    if (best >= 0) { if (c.line !== best + 1) moved++; c.line = best + 1; return true; }
-    dropped.push(c);
-    return false;
+    if (best >= 0 && c.line !== best + 1) { c.line = best + 1; moved++; } // moved to follow the line; not found -> keep as-is
   });
-  if (!dropped.length && !moved) return; // nothing changed — skip the save/re-render
+  if (!moved) return; // nothing moved — skip the save/re-render
   saveComments();
-  var byPath = {};
-  dropped.forEach(function (c) { byPath[c.path] = (byPath[c.path] || 0) + 1; });
-  Object.keys(byPath).forEach(function (p) {
-    showToast(t('toast.commentsDropped').replace('{n}', byPath[p]).replace('{file}', String(p).split('/').pop()));
-  });
   refreshComments();
 }
 function saveComments() {
@@ -1821,6 +1959,14 @@ function addComment(kind, path, line, code, text) {
   reviewComments.push({ seq: commentSeq, kind: kind, path: path, line: line, code: String(code || ''), text: trimmed });
   saveComments();
 }
+// Edit an existing comment in place (e on a selected box -> composer prefilled -> save). Empty text deletes it.
+function updateComment(seq, text) {
+  var c = reviewComments.find(function (x) { return x.seq === seq; });
+  if (!c) return;
+  var trimmed = String(text || '').trim();
+  if (trimmed) { c.text = trimmed; saveComments(); }
+  else { deleteComment(seq); }
+}
 function deleteComment(seq) {
   reviewComments = reviewComments.filter(function (c) { return c.seq !== seq; });
   saveComments();
@@ -1901,6 +2047,7 @@ function composerTargetLabel(s) {
 function threadHtml(path, line) {
   var html = '';
   commentsAt(path, line).forEach(function (c) {
+    if (composerState && composerState.editSeq === c.seq) return; // being edited -> rendered as the composer below
     html += '<div class="mc-card mc-' + c.kind + '">'
       + '<div class="mc-card-head"><span class="mc-kind">' + commentKindLabel(c.kind) + '</span>'
       + '<button type="button" class="mc-del" data-seq="' + c.seq + '" title="' + escapeHtml(t('composer.delete')) + '">×</button></div>'
@@ -1910,7 +2057,7 @@ function threadHtml(path, line) {
     var ph = composerState.kind === 'q' ? t('composer.question') : t('composer.changeRequest');
     html += '<div class="mc-card mc-' + composerState.kind + ' mc-composer">'
       + '<div class="mc-card-head"><span class="mc-kind">' + commentKindLabel(composerState.kind) + '</span><span class="mc-target" title="' + escapeHtml(composerState.path || '') + '">' + escapeHtml(composerTargetLabel(composerState)) + '</span></div>'
-      + '<textarea class="mc-input" rows="3" placeholder="' + escapeHtml(ph) + '"></textarea>'
+      + '<textarea class="mc-input" rows="3" placeholder="' + escapeHtml(ph) + '">' + escapeHtml(composerState.editText || '') + '</textarea>'
       + '<div class="mc-actions"><button type="button" class="mc-btn mc-save">' + escapeHtml(t('composer.save')) + '</button>'
       + '<button type="button" class="mc-btn mc-ghost mc-cancel">' + escapeHtml(t('composer.cancel')) + '</button>'
       + '<span class="mc-hint">' + escapeHtml(t('composer.hint')) + '</span></div></div>';
@@ -2069,6 +2216,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
@@ -2089,9 +2237,11 @@ function saveComposer(ta) {
   if (!composerState) return;
   var box = ta || activeComposerInput();
   if (!box) return;
-  addComment(composerState.kind, composerState.path, composerState.line, composerState.code, box.value);
+  if (composerState.editSeq != null) updateComment(composerState.editSeq, box.value);
+  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
@@ -2233,36 +2383,145 @@ 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() {
+  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();
+}
+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();
+  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();
@@ -2277,57 +2536,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) {
-      showCustomDropdown(x, y, [{ label: t('dropdown.remove'), onSelect: function () { seqs.forEach(deleteComment); rerender(); } }], flipTop);
+      // Select-all / multi-comment: offer send-to-terminal (the whole merged text) FIRST, then remove-all.
+      var multi = [];
+      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(); });
-  // Terminal send (Electron, terminal open): close the modal and hand off to pane-pick mode ON the
-  // terminal — the chosen pane is highlighted, the rest dimmed, arrows change the choice, Enter sends.
-  // One button here; the actual pick happens visually over the live claude/codex sessions.
-  var sendBtn = null;
-  if (window.__monacoriTerminal && typeof window.__monacoriTerminal.isOpen === 'function' && window.__monacoriTerminal.isOpen()) {
-    sendBtn = document.createElement('button');
-    sendBtn.type = 'button';
-    sendBtn.className = 'mc-btn mc-send-term';
-    sendBtn.textContent = t('merged.sendToTerminal');
-    sendBtn.addEventListener('click', function () {
-      var text = buildMergedText(kind);
-      modal.remove();
-      window.__monacoriTerminal.enterSendMode(text);
-    });
-  }
-  head.appendChild(title);
-  if (sendBtn) head.appendChild(sendBtn);
-  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 send button (Enter starts pane-pick) when present, else the read-only text. Electron
-  // async-restores focus to <body>, so retry briefly (same as the composer).
-  var modalFocusTarget = area; // focus the text (not the send button) so the caret is visible and Opt+Arrow/Enter work; Send-to-terminal is a click
-  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
@@ -2345,27 +2575,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;
@@ -2379,45 +2592,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) {
@@ -2623,10 +2816,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) {} });
@@ -2850,8 +3046,10 @@ if (window.monacoriMenu && typeof window.monacoriMenu.onCloseTab === 'function')
   // Capture so closing settings wins over other Escape handlers (lightbox / composer).
   document.addEventListener('keydown', function (e) {
     if (e.key === 'Escape' && !modal.classList.contains('hidden')) { e.stopPropagation(); e.preventDefault(); close(); return; }
-    // Cmd/Ctrl+, (the standard "Preferences" accelerator) toggles the settings panel from anywhere.
+    // Cmd/Ctrl+, (the standard "Preferences" accelerator) toggles the settings panel from anywhere — but not
+    // while another floating overlay (merged / memo) owns focus; that one must be Esc'd first.
     if ((e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey && (e.key === ',' || e.code === 'Comma')) {
+      if (modal.classList.contains('hidden') && (document.getElementById('mc-modal') || document.getElementById('mc-memo'))) return;
       e.preventDefault(); e.stopPropagation();
       if (modal.classList.contains('hidden')) open('general'); else close();
     }
@@ -3000,8 +3198,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');
@@ -3009,6 +3218,23 @@ function applyDiffUpdate(u) {
   var wasSource = isSourceViewerVisible();
   var container = document.getElementById('diff2html-container');
   var diffScrollTop = container ? container.scrollTop : 0;
+  // 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 || '';
@@ -3027,6 +3253,9 @@ function applyDiffUpdate(u) {
   // 2) Re-derive module-level state directly from the payload objects.
   fileStates = u.fileStates || [];
   fileSignatureByPath = new Map(fileStates.map(function (f) { return [f.path, f.signature]; }));
+  // The open file changed iff its signature moved (or it vanished from the new build). Drives whether we
+  // re-render the source view below.
+  var openFileChanged = !openPath || prevOpenSig !== (fileSignatureByPath.get(openPath) || '');
   sourceFiles = u.sourceFilesMeta || [];
   sourceByPath = new Map(sourceFiles.map(function (f) { return [f.path, f]; }));
   httpEnvironments = u.httpEnvironments || {};
@@ -3036,16 +3265,40 @@ function applyDiffUpdate(u) {
   sourceLinks = Array.from(document.querySelectorAll('.source-link'));
 
   // 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
   sourceLoading = false;
-  sourceBodyPath = null; // the new build may have changed the open file's content — force a body re-render on next open
+  // Force a source body re-render on next open ONLY if the open file actually changed; otherwise keep
+  // 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.
+  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);
+    });
+  }
+
   // 4) Re-run the DOM-dependent bootstrap steps.
   applyI18n();
   populateHttpEnvSelect();
@@ -3053,9 +3306,10 @@ function applyDiffUpdate(u) {
   remapComments(); // follow/drop comments whose anchor line moved or vanished in the new build
   refreshComments();
 
-  // 5) Best-effort restore of what the user was looking at.
+  // 5) Best-effort restore of what the user was looking at. Re-render the source view only when the open file
+  // actually changed; an unchanged file stays painted as-is, so an unrelated edit doesn't flicker the pane.
   if (wasSource && openPath && sourceByPath.has(openPath)) {
-    openSourceFile(openPath, false);
+    if (openFileChanged) openSourceFile(openPath, false);
   } else if (container) {
     showDiffView(false);
     container.scrollTop = diffScrollTop;
@@ -3313,6 +3567,17 @@ function setSourceCursor(path, lineIndex, column, shouldReveal = false, targetLi
   recordNav(navEntryOf('source'));
 }
 var sourceRevealRaf = 0, sourceRevealPrev = null;
+// Source rows are a fixed monospace height, so the caret-follow scroll can be computed from
+// lineIndex*rowHeight instead of reading the caret's getBoundingClientRect — which forces a full reflow on
+// every move (~15ms on a 400-line file; the main caret-follow stutter). Cached; invalidated on resize.
+var _srcRowH = 0;
+function sourceRowHeight() {
+  if (_srcRowH > 0) return _srcRowH;
+  var r = document.querySelector('#source-body .source-row');
+  if (r) { var h = r.offsetHeight; if (h > 0) _srcRowH = h; }
+  return _srcRowH;
+}
+if (typeof window !== 'undefined') window.addEventListener('resize', function () { _srcRowH = 0; });
 function scheduleSourceReveal(prev) {
   // First prev of a coalesced burst wins: a fast ArrowDown updates viewerCursor many times before the frame
   // fires; render the caret once (first prev -> final viewerCursor) and scroll in the SAME frame so caret and
@@ -3326,8 +3591,23 @@ function scheduleSourceReveal(prev) {
     if (!f || !f.embedded) return;
     var lines = f.content.split(/\r?\n/);
     updateSourceCaret(p, lines, f.language || 'text');
-    var cl = document.querySelector('.source-row.cursor-line');
-    revealAt(cl, document.getElementById('source-body'), 0.42);
+    var sb = document.getElementById('source-body');
+    var rowH = sourceRowHeight();
+    if (rowH > 0 && sb && !sb.classList.contains('rendered-body')) {
+      // Scrolloff, not follow: scroll ONLY when the caret would otherwise leave the viewport, keeping it
+      // within a 15% margin of the top/bottom edge. While the caret moves comfortably inside that band the
+      // view stays put — continuous follow was dizzying (the file slid even when everything was visible) and
+      // it forced a scroll/reflow on every move. lineIndex*rowH avoids getBoundingClientRect entirely, and
+      // skipping the scroll when it's unnecessary removes the reflow on most moves too.
+      var caretTop = viewerCursor.lineIndex * rowH;
+      var ch = sb.clientHeight;
+      var margin = Math.round(ch * 0.15);
+      var vTop = sb.scrollTop;
+      if (caretTop < vTop + margin) sb.scrollTop = Math.max(0, caretTop - margin);
+      else if (caretTop + rowH > vTop + ch - margin) sb.scrollTop = caretTop + rowH - ch + margin;
+    } else {
+      revealAt(document.querySelector('.source-row.cursor-line'), sb, 0.85);
+    }
   });
 }
 
@@ -3424,9 +3704,9 @@ function selectCommentRow(row) {
   selectedCommentRow = row || null;
   if (!selectedCommentRow) return;
   selectedCommentRow.classList.add('mc-row-selected');
-  // hide the text caret while the box is "selected" (no re-render happens during plain selection)
-  document.querySelectorAll('#source-body .source-row.cursor-line').forEach(function (r) { r.classList.remove('cursor-line'); });
-  document.querySelectorAll('#source-body .code-cursor').forEach(function (s) { var p = s.parentNode; if (p) { p.removeChild(s); if (p.normalize) p.normalize(); } });
+  // Keep the caret visible: the box's active outline (.mc-row-selected) already shows the selection, and the
+  // caret must never be hidden ("어떤 경우에도 커서는 가려지면 안 됨"). Previously this removed cursor-line +
+  // code-cursor, so Go-to-comment → ArrowDown (which selects the comment box on that line) made the caret vanish.
 }
 function deleteCommentsInRow(row) {
   if (!row) return;
@@ -3438,6 +3718,21 @@ function deleteCommentsInRow(row) {
   }
   refreshComments(); // remaining comment rows re-injected; the caret stays hidden until the next arrow press
 }
+// Open the composer in EDIT mode for the first comment in `row`, pre-filled with its text. threadHtml renders
+// the composer in place of that card (via composerState.editSeq), and saveComposer routes editSeq through
+// updateComment instead of addComment. Triggered by `e` while a comment box is selected.
+function editCommentInRow(row) {
+  if (!row) return;
+  var del = row.querySelector('.mc-del');
+  if (!del) return;
+  var seq = parseInt(del.dataset.seq, 10);
+  var c = reviewComments.find(function (x) { return x.seq === seq; });
+  if (!c) return;
+  row.classList.remove('mc-row-selected');
+  selectedCommentRow = null;
+  composerState = { kind: c.kind, path: c.path, line: c.line, code: c.code, editSeq: seq, editText: c.text };
+  refreshComments();
+}
 function handleSourceCaretKey(event) {
   if (!viewerCursor) return false;
   var ae = document.activeElement;
@@ -3446,6 +3741,7 @@ function handleSourceCaretKey(event) {
   // A comment box is selected (caret hidden): Backspace/Delete removes it; an arrow steps off it.
   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);
@@ -4036,6 +4332,7 @@ function toggleRenderMode() {
   var btn = document.getElementById('render-toggle');
   if (btn) btn.addEventListener('click', function () { toggleRenderMode(); });
   document.addEventListener('keydown', function (e) {
+    if (isFloatingModalOpen()) return; // a floating overlay owns focus -> no render-toggle shortcut beneath it
     if ((e.metaKey || e.ctrlKey) && e.shiftKey && !e.altKey && (e.key === 'M' || e.key === 'm' || e.code === 'KeyM')) {
       var sv = document.getElementById('source-viewer');
       var open = sv && sv.dataset.openPath;