@happy-nut/monacori 0.1.2 → 0.1.5

package/dist/viewer.client.js

@@ -113,16 +113,47 @@ function setupLazyDiff() {
   if (wrappers[0]) ensureFileReady(wrappers[0]); // first file ready so the initial caret has a row to land on
 }
 if (REVIEW_LAZY) { setupLazyDiff(); setTimeout(function () { diffBootDone = true; }, 0); }
-const links = Array.from(document.querySelectorAll('#changes-panel .file-link'));
+let links = Array.from(document.querySelectorAll('#changes-panel .file-link')); // re-captured on in-place diff update
 let sourceLinks = Array.from(document.querySelectorAll('.source-link')); // re-captured when a deferred tree materializes
-const sourceFiles = JSON.parse(document.getElementById('source-files-data')?.textContent || '[]');
-const fileStates = JSON.parse(document.getElementById('file-state-data')?.textContent || '[]');
-const httpEnvironments = JSON.parse(document.getElementById('http-env-data')?.textContent || '{}');
-const httpEnvNames = Object.keys(httpEnvironments);
+let sourceFiles = JSON.parse(document.getElementById('source-files-data')?.textContent || '[]');
+// i18n: the message catalog (en + ko) is emitted server-side; the locale lives in localStorage and the
+// whole UI switches live (no reload). t() feeds dynamically-built text; applyI18n() rewrites the static
+// chrome (data-i18n / -ph / -title / -aria). English is the first-paint default.
+var I18N = JSON.parse(document.getElementById('i18n-data')?.textContent || '{}');
+// Cross-reopen persistence. Electron persists via the main process (window.monacoriSettings — survives
+// app restart; file:// localStorage doesn't); browser/serve falls back to localStorage. persistRead
+// returns the bridge value (native) if present, else undefined so callers parse localStorage themselves.
+function persistRead(key) {
+  try { if (window.monacoriSettings && window.monacoriSettings.all && key in window.monacoriSettings.all) return window.monacoriSettings.all[key]; } catch (e) {}
+  return undefined;
+}
+function persistSave(key, value) {
+  try { localStorage.setItem(key, typeof value === 'string' ? value : JSON.stringify(value)); } catch (e) {}
+  try { if (window.monacoriSettings) window.monacoriSettings.set(key, value); } catch (e2) {}
+}
+var LOCALE_KEY = 'monacori-locale';
+var locale = (function () {
+  var v = persistRead(LOCALE_KEY);
+  if (v !== 'ko' && v !== 'en') { try { v = localStorage.getItem(LOCALE_KEY); } catch (e) {} }
+  return (v === 'ko' || v === 'en') ? v : 'en';
+})();
+function t(key) { var m = (I18N[locale] || I18N.en || {}); return (m && key in m) ? m[key] : ((I18N.en && I18N.en[key]) || key); }
+function applyI18n() {
+  document.querySelectorAll('[data-i18n]').forEach(function (el) { el.textContent = t(el.getAttribute('data-i18n')); });
+  document.querySelectorAll('[data-i18n-ph]').forEach(function (el) { el.setAttribute('placeholder', t(el.getAttribute('data-i18n-ph'))); });
+  document.querySelectorAll('[data-i18n-title]').forEach(function (el) { el.setAttribute('title', t(el.getAttribute('data-i18n-title'))); });
+  document.querySelectorAll('[data-i18n-aria]').forEach(function (el) { el.setAttribute('aria-label', t(el.getAttribute('data-i18n-aria'))); });
+  document.documentElement.lang = locale;
+  var sel = document.getElementById('settings-language');
+  if (sel) sel.value = locale;
+}
+let fileStates = JSON.parse(document.getElementById('file-state-data')?.textContent || '[]');
+let httpEnvironments = JSON.parse(document.getElementById('http-env-data')?.textContent || '{}');
+let httpEnvNames = Object.keys(httpEnvironments);
 const httpEnvKey = 'monacori-http-env:' + location.pathname;
 const httpRequestsByPath = new Map();
 const httpVarsByPath = new Map();
-const sourceByPath = new Map(sourceFiles.map((file) => [file.path, file]));
+let sourceByPath = new Map(sourceFiles.map((file) => [file.path, file]));
 // Phase 2b lazy-LOAD: source content is fetched once after first paint (serve /source-data or the
 // Electron bridge) and merged into the metadata-only source records; until then sourceLoaded is false
 // and the source view shows a brief loading state. Non-lazy-load modes embed source -> already loaded.
@@ -130,6 +161,7 @@ var sourceLoaded = !REVIEW_LAZY_LOAD;
 var pendingSourceOpen = null;
 var sourceLoading = false;
 var pendingSymbol = null;
+var sourceTabs = []; // Files-mode tab paths (session-only); see addSourceTab / renderSourceTabs.
 // The source blob (content + image base64) is large on big repos, so lazy-LOAD fetches it lazily — on
 // the first source-view open or go-to-definition — not eagerly at startup. Idempotent.
 function loadSourceData() {
@@ -152,16 +184,16 @@ function loadSourceData() {
     }
     sourceLoaded = true;
     sourceLoading = false;
-    try { startSymbolIndex(); } catch (e) {}
+    scheduleSymbolIndex();
     if (pendingSourceOpen) { var po = pendingSourceOpen; pendingSourceOpen = null; openSourceFile(po.path, po.shouldSwitch); }
     else if (isSourceViewerVisible() && document.getElementById('source-viewer').dataset.openPath) { openSourceFile(document.getElementById('source-viewer').dataset.openPath, false); }
     if (pendingSymbol) { var s = pendingSymbol; pendingSymbol = null; goToDefOrUsages(s); }
   }, function () { sourceLoaded = true; sourceLoading = false; });
 }
-const fileSignatureByPath = new Map(fileStates.map((file) => [file.path, file.signature]));
+let fileSignatureByPath = new Map(fileStates.map((file) => [file.path, file.signature]));
 const reviewMeta = document.getElementById('review-meta');
 const watchEnabled = reviewMeta?.dataset.watch === 'true';
-const currentSignature = reviewMeta?.dataset.signature || '';
+let currentSignature = reviewMeta?.dataset.signature || '';
 const uiStateKey = 'monacori-diff-ui:' + location.pathname;
 const recentKey = 'monacori-diff-recent:' + location.pathname;
 const viewedKey = 'monacori-diff-viewed:' + location.pathname;
@@ -202,7 +234,7 @@ let measuredCharWidth = 0;
 // restoreUiState()/openDefaultSourceFile() run on startup and try to render them.
 var COMMENTS_KEY = 'monacori-comments:' + location.pathname;
 var reviewComments = [];
-try { reviewComments = JSON.parse(localStorage.getItem(COMMENTS_KEY) || '[]'); } catch (commentsErr) { reviewComments = []; }
+reviewComments = (function () { var b = persistRead(COMMENTS_KEY); if (Array.isArray(b)) return b; try { return JSON.parse(localStorage.getItem(COMMENTS_KEY) || '[]'); } catch (commentsErr) { return []; } })();
 if (!Array.isArray(reviewComments)) reviewComments = [];
 var commentSeq = reviewComments.reduce(function (max, c) { return Math.max(max, c.seq || 0); }, 0);
 var composerState = null;
@@ -243,7 +275,7 @@ function prepareViewedControls() {
     const toggle = wrapper.querySelector('.d2h-file-collapse');
     const input = toggle?.querySelector('input');
     if (!fileName || !toggle || !input) return;
-    toggle.title = 'Toggle viewed (<)';
+    toggle.title = t('btn.viewed.title');
     input.tabIndex = -1;
     toggle.addEventListener('click', (event) => {
       event.preventDefault();
@@ -407,14 +439,42 @@ function renderBreadcrumb(container, path) {
   });
 }
 
+// Coalesce diff-nav scrolls: hammering F7 / [ / ] schedules at most one
+// scrollIntoView per frame (to the latest target) instead of forcing a
+// synchronous reflow on every keystroke.
+var pendingDiffScrollRow = null;
+var diffScrollRaf = 0;
+function scheduleDiffScroll(row) {
+  pendingDiffScrollRow = row || null;
+  if (diffScrollRaf) return;
+  diffScrollRaf = requestAnimationFrame(function () {
+    diffScrollRaf = 0;
+    var r = pendingDiffScrollRow;
+    pendingDiffScrollRow = null;
+    if (r && r.scrollIntoView) r.scrollIntoView({ block: 'center' });
+  });
+}
+
+var setActiveRaf = 0, setActiveScrollPending = true;
 function setActive(index, shouldScroll = true) {
   if (hunkTotal() === 0) return;
   current = ((index % hunkTotal()) + hunkTotal()) % hunkTotal();
+  // Coalesce rapid presses (holding/spamming F7 or Shift+F7) into one DOM apply per animation frame. The
+  // key handler returns immediately and `current` updates synchronously (so next()/nav math stays correct),
+  // while the heavy DOM work (full link/wrapper sweeps, body materialize) runs at most once per frame
+  // instead of once per keystroke — the input queue never blocks and can't pile up on big repos.
+  setActiveScrollPending = shouldScroll;
+  if (setActiveRaf) return;
+  setActiveRaf = requestAnimationFrame(function () {
+    setActiveRaf = 0;
+    applySetActive(current, setActiveScrollPending);
+  });
+}
+function applySetActive(idx, shouldScroll) {
   document.getElementById('source-viewer')?.classList.add('hidden');
   document.getElementById('diff-view')?.classList.remove('hidden');
   setTab('changes');
-  const file = hunkPathAt(current);
-  const idx = current;
+  const file = hunkPathAt(idx);
   links.forEach((link) => link.classList.toggle('active', link.dataset.file === file));
   renderBreadcrumb(document.getElementById('diff-breadcrumb'), file);
   var dvt = document.getElementById('diff-viewed-toggle');
@@ -438,15 +498,14 @@ function setActive(index, shouldScroll = true) {
     // 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) targetRow.scrollIntoView({ block: 'center' });
+    if (shouldScroll && targetRow) scheduleDiffScroll(targetRow);
   });
 }
 
 function showOnlyFile(fileName) {
   if (REVIEW_LAZY) ensureFileReady(diffWrapperByPath(fileName));
   document.querySelectorAll('.d2h-file-wrapper').forEach((wrapper) => {
-    const name = wrapper.querySelector('.d2h-file-name')?.textContent?.trim() || '';
-    wrapper.classList.toggle('df-inactive', name !== fileName);
+    wrapper.classList.toggle('df-inactive', diffWrapperPathKey(wrapper) !== fileName);
   });
   ensureDiffCursor();
 }
@@ -474,8 +533,10 @@ function hunkIndexAtCaret() {
 // New-side row indices, one per change block — a run of change rows (ins/del) separated by context.
 // A wide context window merges several edits into one @@ hunk; stepping by these stops at each edit.
 function changeBlockAnchors(wrapper) {
+  if (!wrapper) return [];
+  if (wrapper.__anchors) return wrapper.__anchors;
   var right = diffSideTables(wrapper).right;
-  if (!right) return [];
+  if (!right) return []; // body not materialized yet — don't cache an empty result
   var rows = diffRowsOf(right);
   var anchors = [];
   var prev = false;
@@ -484,6 +545,7 @@ function changeBlockAnchors(wrapper) {
     if (chg && !prev) anchors.push(i);
     prev = chg;
   }
+  wrapper.__anchors = anchors; // change-block layout is static once materialized
   return anchors;
 }
 
@@ -501,7 +563,7 @@ function next(delta) {
       else { for (let b = anchors.length - 1; b >= 0; b--) { if (anchors[b] < cur) { target = anchors[b]; break; } } }
       if (target != null) {
         const row = diffRowAt(w, 'new', target);
-        if (row) { navSuppress = true; try { focusDiffRow(row); } finally { navSuppress = false; } row.scrollIntoView({ block: 'center' }); return; }
+        if (row) { navSuppress = true; try { focusDiffRow(row); } finally { navSuppress = false; } scheduleDiffScroll(row); return; }
       }
     }
   }
@@ -535,7 +597,7 @@ function firstHunkForPath(path) {
 function openQuickOpen(mode) {
   if (!quickOpen || !quickInput || !quickModeLabel) return;
   quickMode = mode;
-  quickModeLabel.textContent = mode === 'recent' ? 'Recent files' : mode === 'content' ? 'Find in Files' : 'Search files';
+  quickModeLabel.textContent = mode === 'recent' ? t('quickopen.recent') : mode === 'content' ? t('quickopen.findInFiles') : t('quickopen.searchFiles');
   quickOpen.classList.remove('hidden');
   quickInput.value = '';
   renderQuickOpenResults();
@@ -590,7 +652,7 @@ function renderQuickOpenResults() {
     .slice(0, 80);
   quickActive = Math.min(quickActive, Math.max(quickItems.length - 1, 0));
   if (quickItems.length === 0) {
-    quickResults.innerHTML = '<div class="quick-open-empty">No files found.</div>';
+    quickResults.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t('quickopen.noFiles')) + '</div>';
     return;
   }
   quickResults.innerHTML = quickItems.map((item, index) => [
@@ -923,6 +985,13 @@ document.addEventListener('keydown', (event) => {
     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;
+  }
   // "?" = 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;
@@ -1063,6 +1132,9 @@ document.addEventListener('keydown', (event) => {
   }
 
   // Cmd/Ctrl+[ / ] walk the cursor-position history (back / forward), like an editor's Go Back/Forward.
+  if ((event.metaKey || event.ctrlKey) && event.shiftKey && !event.altKey && (event.key === '[' || event.key === ']' || event.key === '{' || event.key === '}')) {
+    if (isSourceViewerVisible() && sourceTabs.length > 1) { event.preventDefault(); cycleSourceTab((event.key === '[' || event.key === '{') ? -1 : 1); return; }
+  }
   if ((event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey && (event.key === '[' || event.key === ']')) {
     var navEl = document.activeElement;
     var navInField = navEl && (navEl.tagName === 'INPUT' || navEl.tagName === 'TEXTAREA' || navEl.tagName === 'SELECT');
@@ -1139,6 +1211,12 @@ document.querySelectorAll('.tab').forEach((button) => {
 });
 
 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');
+  if (closeBtn) { event.stopPropagation(); event.preventDefault(); closeSourceTab(closeBtn.getAttribute('data-close-path')); return; }
+  var tab = event.target && event.target.closest && event.target.closest('.source-tab');
+  if (tab) openSourceFile(tab.getAttribute('data-tab-path'));
+});
 document.getElementById('diff-viewed-toggle')?.addEventListener('click', function () {
   var btn = document.getElementById('diff-viewed-toggle');
   var path = btn ? (btn.dataset.file || '') : '';
@@ -1154,11 +1232,12 @@ document.addEventListener('keydown', function (event) {
 }, true);
 document.addEventListener('copy', handleSourceCopy);
 
+applyI18n(); // first paint already shows English (inline); this swaps to the saved locale before the rest of init renders dynamic text
 populateHttpEnvSelect();
-if (!REVIEW_LAZY_LOAD) setTimeout(startSymbolIndex, 0); // non-lazy indexes now; lazy-LOAD defers the (large) source blob + index to the first source-view open / go-to-def
+if (!REVIEW_LAZY_LOAD) scheduleSymbolIndex(); // non-lazy indexes when idle; lazy-LOAD defers the (large) source blob + index to the first source-view open / go-to-def
 const restored = restoreUiState();
 if (!restored) {
-  const initial = location.hash.match(/^#hunk-(\\d+)$/);
+  const initial = location.hash.match(/^#hunk-(\d+)$/);
   if (initial) setActive(Number(initial[1]), false);
   else if (REVIEW_LAZY_LOAD) showDiffView(false); // big repos: open to the diff (Changes); the source tree stays deferred until the Files tab is opened
   else openDefaultSourceFile();
@@ -1167,6 +1246,19 @@ initSourceTreeFolds();
 if (watchEnabled) setInterval(checkForLiveUpdate, 1500);
 window.addEventListener('beforeunload', saveUiState);
 
+// First render has painted — drop the boot overlay (it bridged the blank gap right after loadFile). Two
+// rAFs so the spinner stays until the diff/tree are actually on screen, then a short fade-out.
+(function () {
+  var ov = document.getElementById('boot-overlay');
+  if (!ov) return;
+  requestAnimationFrame(function () {
+    requestAnimationFrame(function () {
+      ov.classList.add('hide');
+      setTimeout(function () { ov.remove(); }, 240);
+    });
+  });
+})();
+
 (function setupSidebarResize() {
   const resizer = document.querySelector('.sidebar-resizer');
   if (!resizer) return;
@@ -1234,13 +1326,26 @@ function diffActiveWrapper() {
   return document.querySelector('#diff2html-container .d2h-file-wrapper:not(.df-inactive)')
     || document.querySelector('#diff2html-container .d2h-file-wrapper');
 }
+// path -> wrapper, O(1) after the first build. Rebuilt only on a miss/disconnect
+// (the wrapper set is stable; only bodies materialize). This is called several times
+// per F7 press, so the old O(files) querySelector scan made each keystroke cost scale
+// with the file count — the main source of cross-file nav stutter on big diffs.
+var wrapperPathMap = null;
+function diffWrapperPathKey(w) {
+  return (w.dataset && w.dataset.path) || ((w.querySelector('.d2h-file-name') || {}).textContent || '').trim();
+}
 function diffWrapperByPath(path) {
+  if (wrapperPathMap) {
+    var hit = wrapperPathMap.get(path);
+    if (hit && hit.isConnected) return hit;
+  }
+  wrapperPathMap = new Map();
   var ws = document.querySelectorAll('#diff2html-container .d2h-file-wrapper');
   for (var i = 0; i < ws.length; i++) {
-    var n = ws[i].querySelector('.d2h-file-name');
-    if (n && (n.textContent || '').trim() === path) return ws[i];
+    var key = diffWrapperPathKey(ws[i]);
+    if (key) wrapperPathMap.set(key, ws[i]);
   }
-  return null;
+  return wrapperPathMap.get(path) || null;
 }
 function diffSideTables(wrapper) {
   var sides = wrapper ? wrapper.querySelectorAll('.d2h-file-side-diff') : [];
@@ -1338,6 +1443,7 @@ function renderDiffCaret() {
   } catch (e) { diffCaretSpan = null; }
 }
 function setDiffCursor(path, side, rowIndex, column, reveal) {
+  markCaretBusy();
   var wrapper = diffWrapperByPath(path);
   if (!wrapper) return;
   var rows = diffRowsOf(diffSideTable(wrapper, side));
@@ -1513,13 +1619,13 @@ function handleDiffCaretKey(event) {
 // ===== Review comments: questions ("?") and change-requests (">") =====
 // (COMMENTS_KEY / reviewComments / commentSeq / composerState are declared near the top of the script)
 function saveComments() {
-  try { localStorage.setItem(COMMENTS_KEY, JSON.stringify(reviewComments)); } catch (e) {}
+  persistSave(COMMENTS_KEY, reviewComments);
 }
 function commentsAt(path, line) {
   return reviewComments.filter(function (c) { return c.path === path && c.line === line; });
 }
 function commentKindLabel(kind) {
-  return kind === 'q' ? '❓ Question' : '✎ Change request';
+  return kind === 'q' ? t('comment.kind.q') : t('comment.kind.c');
 }
 function relevantLines(path) {
   var set = {};
@@ -1607,17 +1713,17 @@ function threadHtml(path, line) {
   commentsAt(path, line).forEach(function (c) {
     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="Delete">×</button></div>'
+      + '<button type="button" class="mc-del" data-seq="' + c.seq + '" title="' + escapeHtml(t('composer.delete')) + '">×</button></div>'
       + '<div class="mc-card-body">' + escapeHtml(c.text) + '</div></div>';
   });
   if (composerState && composerState.path === path && composerState.line === line) {
-    var ph = composerState.kind === 'q' ? 'Ask a question about this line' : 'Request a change for this 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></div>'
-      + '<textarea class="mc-input" rows="3" placeholder="' + ph + '"></textarea>'
-      + '<div class="mc-actions"><button type="button" class="mc-btn mc-save">Comment</button>'
-      + '<button type="button" class="mc-btn mc-ghost mc-cancel">Cancel</button>'
-      + '<span class="mc-hint">Cmd/Ctrl+Enter to save, Esc to cancel</span></div></div>';
+      + '<textarea class="mc-input" rows="3" placeholder="' + escapeHtml(ph) + '"></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>';
   }
   return html;
 }
@@ -1684,8 +1790,8 @@ function renderCommentBadges() {
     var badge = document.createElement('span');
     badge.className = 'mc-file-badge';
     var html = '';
-    if (k.q) html += '<span class="mc-fb mc-fb-q" title="' + k.q + ' question(s)">' + k.q + '</span>';
-    if (k.c) html += '<span class="mc-fb mc-fb-c" title="' + k.c + ' change request(s)">' + k.c + '</span>';
+    if (k.q) html += '<span class="mc-fb mc-fb-q" title="' + k.q + ' ' + escapeHtml(t('badge.questions')) + '">' + k.q + '</span>';
+    if (k.c) html += '<span class="mc-fb mc-fb-c" title="' + k.c + ' ' + escapeHtml(t('badge.changeRequests')) + '">' + k.c + '</span>';
     badge.innerHTML = html;
     return badge;
   }
@@ -1727,18 +1833,23 @@ function refreshComments() {
   renderCommentBadges();
   applyCommentSelectionHighlight();
   if (composerState) {
-    var focusComposerInput = function () {
+    var composerFocusTries = 0;
+    var tryFocusComposer = function () {
       var ta = document.querySelector('.mc-composer .mc-input');
-      if (ta && document.activeElement !== ta) {
-        try { ta.focus({ preventScroll: true }); } catch (e) { try { ta.focus(); } catch (e2) {} }
-        try { ta.selectionStart = ta.selectionEnd = ta.value.length; } catch (e3) {}
-      }
+      if (!ta) return true;                            // composer gone — stop retrying
+      if (document.activeElement === ta) return true;  // already focused — done
+      try { ta.focus({ preventScroll: true }); } catch (e) { try { ta.focus(); } catch (e2) {} }
+      try { ta.selectionStart = ta.selectionEnd = ta.value.length; } catch (e3) {}
+      return document.activeElement === ta;
     };
-    // Focus now, next frame, and next task: after a drag the browser may async-restore focus to
-    // the body (esp. in Electron), so retry across all three so the textarea reliably wins.
-    focusComposerInput();
-    requestAnimationFrame(focusComposerInput);
-    setTimeout(focusComposerInput, 0);
+    // A one-shot focus works in a plain browser, but Electron asynchronously restores focus to <body>
+    // after the keydown, so the textarea loses that race. Retry on a short interval until it wins (or the
+    // composer closes), capped at ~300ms so it never fights real user focus once they start typing.
+    if (!tryFocusComposer()) {
+      var composerFocusIv = setInterval(function () {
+        if (tryFocusComposer() || ++composerFocusTries > 12) clearInterval(composerFocusIv);
+      }, 25);
+    }
   }
 }
 
@@ -1765,18 +1876,34 @@ function saveComposer(ta) {
   refreshComments();
 }
 
+// Default merge-prompt headings, localized: a Korean user gets Korean defaults. Editable in
+// Settings → Merge prompts (stored per browser in localStorage); buildMergedText + the textarea
+// placeholders fall back to these when the stored value is empty.
+function defaultMergePrompt(kind) {
+  return t(kind === 'q' ? 'mergePrompt.default.q' : 'mergePrompt.default.c');
+}
+var mergePromptsKey = 'monacori-merge-prompts';
+function loadMergePrompts() {
+  var b = persistRead(mergePromptsKey); if (b && typeof b === 'object') return b; try { var v = JSON.parse(localStorage.getItem(mergePromptsKey) || '{}'); return (v && typeof v === 'object') ? v : {}; } catch (e) { return {}; }
+}
+function mergePromptFor(kind) {
+  var v = loadMergePrompts()[kind];
+  return (typeof v === 'string' && v.trim()) ? v : defaultMergePrompt(kind);
+}
+function saveMergePrompt(kind, text) {
+  var saved = loadMergePrompts();
+  if (text && text.trim()) saved[kind] = text; else delete saved[kind];
+  persistSave(mergePromptsKey, saved);
+}
+
 function buildMergedText(kind) {
   var items = reviewComments.filter(function (c) { return c.kind === kind; });
   var nl = String.fromCharCode(10);
   var lines = [];
-  // Per-kind agent contract: questions are the understand-phase (answer, don't edit); change
-  // requests are the act-phase (edit the code). The merged view is an editable textarea, so the
-  // reviewer can trim or localize this before copying.
-  lines.push(kind === 'q'
-    ? 'The following are questions about code you just wrote. Answer each one — explain the intent, rationale, or context. Do not change any code; this clarifies understanding before any revisions.'
-    : 'The following are change requests for code you just wrote. For each, edit the code at the quoted location to satisfy the request. Keep changes minimal and focused; do not make unrelated edits.');
+  // Per-kind agent contract heading (editable in Settings → Merge prompts; default otherwise).
+  lines.push(mergePromptFor(kind));
   lines.push('');
-  lines.push((kind === 'q' ? '# Questions' : '# Change requests') + ' (' + items.length + ')');
+  lines.push((kind === 'q' ? t('merged.qHeading') : t('merged.cHeading')) + ' (' + items.length + ')');
   lines.push('');
   items.forEach(function (c) {
     lines.push('### ' + c.path + ':' + c.line);
@@ -1793,35 +1920,39 @@ function openMergedView(kind) {
   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
   var panel = document.createElement('div');
   panel.className = 'mc-modal-panel';
   var head = document.createElement('div');
   head.className = 'mc-modal-head';
   var title = document.createElement('span');
-  title.textContent = kind === 'q' ? 'Question comments' : 'Change-request comments';
-  var copyBtn = document.createElement('button');
-  copyBtn.type = 'button';
-  copyBtn.className = 'mc-btn';
-  copyBtn.textContent = 'Copy all';
+  title.textContent = kind === 'q' ? t('merged.qTitle') : t('merged.cTitle');
   var closeBtn = document.createElement('button');
   closeBtn.type = 'button';
   closeBtn.className = 'mc-btn mc-ghost';
-  closeBtn.textContent = 'Close';
+  closeBtn.textContent = t('merged.close');
   var area = document.createElement('textarea');
   area.className = 'mc-modal-text';
   area.readOnly = true;
   area.value = buildMergedText(kind);
-  copyBtn.addEventListener('click', function () {
-    area.focus(); area.select();
-    var ok = false;
-    try { ok = document.execCommand('copy'); } catch (e) {}
-    if (navigator.clipboard && navigator.clipboard.writeText) { try { navigator.clipboard.writeText(area.value); ok = true; } catch (e) {} }
-    copyBtn.textContent = ok ? 'Copied' : 'Copy failed';
-    setTimeout(function () { copyBtn.textContent = 'Copy all'; }, 1500);
-  });
   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);
-  head.appendChild(copyBtn);
+  if (sendBtn) head.appendChild(sendBtn);
   head.appendChild(closeBtn);
   panel.appendChild(head);
   panel.appendChild(area);
@@ -1829,7 +1960,109 @@ function openMergedView(kind) {
   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);
-  requestAnimationFrame(function () { area.focus(); area.select(); });
+  // 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 = sendBtn || area;
+  var modalFocusTries = 0;
+  var tryFocusModal = function () {
+    if (!document.getElementById('mc-modal')) return true;
+    if (document.activeElement === modalFocusTarget) return true;
+    try { modalFocusTarget.focus(); if (modalFocusTarget === area) modalFocusTarget.select(); } catch (e) {}
+    return document.activeElement === modalFocusTarget;
+  };
+  if (!tryFocusModal()) {
+    var modalFocusIv = setInterval(function () { if (tryFocusModal() || ++modalFocusTries > 12) clearInterval(modalFocusIv); }, 25);
+  }
+}
+
+// Prompt memo (Cmd/Ctrl+Shift+N): one freeform Markdown scratchpad with a live split preview, persisted
+// across reopens via the same store as comments/locale. "Send to terminal" hands the current draft to the
+// same pane-pick mode the merged views use, so a half-formed prompt can target any live claude/codex session.
+var memoKey = 'monacori-memo';
+function loadMemo() {
+  var v = persistRead(memoKey);
+  if (typeof v === 'string') return v;
+  try { var s = localStorage.getItem(memoKey); return typeof s === 'string' ? s : ''; } catch (e) { return ''; }
+}
+function saveMemo(text) { persistSave(memoKey, text || ''); }
+function renderMemoMd(text) {
+  if (!text || !text.trim()) return '<div class="mc-memo-empty" data-i18n="memo.previewEmpty">' + escapeHtml(t('memo.previewEmpty')) + '</div>';
+  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';
+  var area = document.createElement('textarea');
+  area.className = 'mc-modal-text mc-memo-edit';
+  area.spellcheck = false;
+  area.setAttribute('data-i18n-ph', 'memo.placeholder');
+  area.placeholder = t('memo.placeholder');
+  area.value = loadMemo();
+  var preview = document.createElement('div');
+  preview.className = 'md-cell mc-memo-preview';
+  preview.innerHTML = renderMemoMd(area.value);
+  area.addEventListener('input', function () {
+    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;
+  if (window.__monacoriTerminal && typeof window.__monacoriTerminal.paneCount === 'function' && window.__monacoriTerminal.paneCount() > 0) {
+    sendBtn = document.createElement('button');
+    sendBtn.type = 'button';
+    sendBtn.className = 'mc-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();
+      window.__monacoriTerminal.enterSendMode(text);
+    });
+  }
+
+  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);
+  }
 }
 
 document.addEventListener('click', function (event) {
@@ -1849,11 +2082,322 @@ document.addEventListener('keydown', function (event) {
 
 refreshComments();
 
+
+// Integrated terminal (Electron only): xterm panes wired to node-pty sessions in the main process.
+// Toggle with Ctrl+` / Opt+F12 / the footer ⌗ button; Cmd/Ctrl+D splits the active pane (side by side,
+// no tabs); drag the top edge to resize. window.__monacoriTerminal pipes the merged prompt into the
+// active pane. Cmd combos are released back to the app so shortcuts like Cmd+1 don't get stuck typing.
+(function setupTerminal() {
+  if (!window.monacoriPty) return; // xterm (window.Terminal) is loaded lazily on first open
+  var panel = document.getElementById('terminal-panel');
+  var host = document.getElementById('terminal-host');
+  var toggleBtn = document.getElementById('terminal-toggle');
+  var closeBtn = document.getElementById('terminal-close');
+  var resizer = panel ? panel.querySelector('.terminal-resizer') : null;
+  if (!panel || !host) return;
+  if (toggleBtn) toggleBtn.classList.remove('hidden'); // reveal the footer toggle in Electron
+
+  // xterm ships as an inert island (id=xterm-code) so ~490KB isn't parsed at startup. Inject it on the
+  // first open; returns false if unavailable (e.g. the island is absent), so callers can bail gracefully.
+  function ensureXterm() {
+    if (typeof window.Terminal === 'function') return true;
+    var code = document.getElementById('xterm-code');
+    if (!code) return false;
+    try {
+      var s = document.createElement('script');
+      s.textContent = code.textContent;
+      document.head.appendChild(s);
+      code.remove(); // free the inert text once compiled
+    } catch (e) { return false; }
+    return typeof window.Terminal === 'function';
+  }
+
+  var panes = [];   // { id, term, fit, el }
+  var active = null;
+  var MAX_PANES = 4;
+  var heightKey = 'monacori-terminal-height';
+  var openKey = 'monacori-terminal-open:' + location.pathname;
+
+  function applyHeight(px) {
+    var h = Math.max(120, Math.min(px, window.innerHeight - 120));
+    document.documentElement.style.setProperty('--terminal-height', h + 'px');
+  }
+  var savedH = parseInt(localStorage.getItem(heightKey) || '', 10);
+  if (savedH) applyHeight(savedH);
+
+  function fitPane(p) {
+    if (!p) return;
+    try { p.fit.fit(); if (p.id != null) window.monacoriPty.resize({ id: p.id, cols: p.term.cols, rows: p.term.rows }); } catch (e) {}
+  }
+  function fitAll() { panes.forEach(fitPane); }
+
+  function setActive(p) {
+    active = p;
+    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.
+      q.el.classList.toggle('is-inactive', panes.length > 1 && q !== p);
+    });
+    if (p) requestAnimationFrame(function () { try { p.term.focus(); } catch (e) {} });
+  }
+
+  function makePane() {
+    if (!ensureXterm()) return null; // xterm unavailable — leave the panel empty rather than throw
+    var el = document.createElement('div');
+    el.className = 'terminal-pane';
+    var labelEl = document.createElement('div');
+    labelEl.className = 'terminal-pane-label';
+    var paneHost = document.createElement('div');
+    paneHost.className = 'terminal-pane-host';
+    el.appendChild(labelEl);
+    el.appendChild(paneHost);
+    host.appendChild(el);
+    var term = new window.Terminal({
+      fontSize: 12,
+      fontFamily: 'Monaco, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
+      theme: { background: '#161616', foreground: '#a9b7c6', cursor: '#a9b7c6', selectionBackground: '#214283' },
+      cursorBlink: true,
+    });
+    var fit = new window.FitAddon.FitAddon();
+    term.loadAddon(fit);
+    term.open(paneHost);
+    var pane = { id: null, term: term, fit: fit, el: el, labelEl: labelEl, name: 'Terminal ' + (panes.length + 1) };
+    labelEl.textContent = pane.name;
+    // Cmd combos are app shortcuts (Cmd+1/0 tab switch, Cmd+B go-to-def, …). Release the terminal and let
+    // them bubble to the document handler instead of typing into the shell (fixes "Cmd+1 stuck in term").
+    // Exception: keep focus for clipboard/selection combos (Cmd+C/V/X/A) so the terminal's own copy &
+    // paste keep working — blurring on Cmd+V drops the textarea focus the paste event needs.
+    term.attachCustomKeyEventHandler(function (e) {
+      if (e.type === 'keydown' && e.metaKey) {
+        var k = (e.key || '').toLowerCase();
+        // The bare modifier press (Cmd goes down BEFORE the letter on macOS) must not blur — blurring
+        // here drops the textarea focus the upcoming Cmd+V paste / Cmd+C copy needs, which broke them.
+        if (k === 'meta' || k === 'control' || k === 'alt' || k === 'shift') return true;
+        // 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.
+        if (e.code === 'KeyC' || e.code === 'KeyV' || e.code === 'KeyX' || e.code === 'KeyA') return true;
+        try { term.blur(); } catch (x) {}
+        return false;
+      }
+      return true;
+    });
+    term.onData(function (d) { if (pane.id != null) window.monacoriPty.write({ id: pane.id, data: d }); });
+    el.addEventListener('mousedown', function (e) { if (e.target !== labelEl) setActive(pane); });
+    labelEl.addEventListener('dblclick', function () { renamePane(pane); });
+    panes.push(pane);
+    try { fit.fit(); } catch (e) {}
+    window.monacoriPty.spawn({ cols: term.cols || 80, rows: term.rows || 24 }).then(function (r) { pane.id = r && r.id; });
+    setActive(pane);
+    return pane;
+  }
+  // Rename a pane inline: the label becomes editable, Enter commits, Esc/blur reverts to the last name.
+  function renamePane(pane) {
+    if (!pane) { pane = active; }
+    if (!pane) return;
+    var el = pane.labelEl;
+    if (el.getAttribute('contenteditable') === 'true') return;
+    setActive(pane);
+    el.contentEditable = 'true';
+    // Electron asynchronously restores focus to <body> after the keydown, so a one-shot focus loses the
+    // race and the label turns editable but never gets the caret — retry until it sticks, then select all
+    // (same pattern as the composer/memo). This is why rename "did nothing" before.
+    var renameTries = 0;
+    var focusLabel = function () {
+      if (el.getAttribute('contenteditable') !== 'true') return true; // finished/cancelled meanwhile
+      try { el.focus(); } catch (e) {}
+      if (document.activeElement !== el) return false;
+      try { var range = document.createRange(); range.selectNodeContents(el); var sel = window.getSelection(); sel.removeAllRanges(); sel.addRange(range); } catch (e) {}
+      return true;
+    };
+    if (!focusLabel()) { var renameIv = setInterval(function () { if (focusLabel() || ++renameTries > 12) clearInterval(renameIv); }, 25); }
+    function finish(commit) {
+      el.removeEventListener('keydown', onKey);
+      el.removeEventListener('blur', onBlur);
+      el.contentEditable = 'false';
+      if (commit) pane.name = (el.textContent || '').trim() || pane.name;
+      el.textContent = pane.name;
+      try { if (pane.term) pane.term.focus(); } catch (e) {}
+    }
+    function onKey(e) {
+      e.stopPropagation();
+      if (e.key === 'Enter') { e.preventDefault(); finish(true); }
+      else if (e.key === 'Escape') { e.preventDefault(); finish(false); }
+    }
+    function onBlur() { finish(true); }
+    el.addEventListener('keydown', onKey);
+    el.addEventListener('blur', onBlur);
+  }
+
+  function removePane(id) {
+    var i = -1;
+    for (var k = 0; k < panes.length; k++) { if (panes[k].id === id) { i = k; break; } }
+    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);
+    if (active === p) setActive(panes[panes.length - 1] || null);
+    if (panes.length === 0) setOpen(false);
+    else fitAll();
+  }
+
+  function split() {
+    if (panes.length >= MAX_PANES) return;
+    makePane();
+    fitAll();
+  }
+  // Move active focus between split panes (menu accelerators Cmd/Ctrl+Alt+[ and ]).
+  function focusPaneByDelta(delta) {
+    if (panes.length < 2) return;
+    var i = panes.indexOf(active);
+    if (i < 0) i = 0;
+    setActive(panes[(i + delta + panes.length) % panes.length]);
+  }
+
+  // Route per-pane pty output / exit by id (registered once for the window).
+  window.monacoriPty.onData(function (msg) {
+    for (var k = 0; k < panes.length; k++) { if (panes[k].id === msg.id) { panes[k].term.write(msg.data); return; } }
+  });
+  window.monacoriPty.onExit(function (msg) { removePane(msg.id); });
+
+  function isOpen() { return !panel.classList.contains('hidden'); }
+  function setOpen(open) {
+    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 (open) {
+      if (panes.length === 0) makePane();
+      requestAnimationFrame(function () { fitAll(); if (active) try { active.term.focus(); } catch (e) {} });
+    }
+  }
+  function toggle() { setOpen(!isOpen()); }
+
+  if (toggleBtn) toggleBtn.addEventListener('click', toggle);
+  if (closeBtn) closeBtn.addEventListener('click', function () { setOpen(false); });
+  // Toggle (Ctrl+`/Alt+F12) and split (Cmd+D) arrive from the Terminal menu accelerators (app-main),
+  // because Chromium swallows Cmd+D before a renderer keydown would ever see it.
+  if (window.monacoriMenu && typeof window.monacoriMenu.onTerminalToggle === 'function') window.monacoriMenu.onTerminalToggle(toggle);
+  if (window.monacoriMenu && typeof window.monacoriMenu.onTerminalSplit === 'function') window.monacoriMenu.onTerminalSplit(split);
+  if (window.monacoriMenu && typeof window.monacoriMenu.onTerminalPaneFocus === 'function') window.monacoriMenu.onTerminalPaneFocus(focusPaneByDelta);
+  if (window.monacoriMenu && typeof window.monacoriMenu.onTerminalPaneRename === 'function') window.monacoriMenu.onTerminalPaneRename(function () { renamePane(active); });
+
+  var ro = (typeof ResizeObserver === 'function') ? new ResizeObserver(function () { if (isOpen()) fitAll(); }) : null;
+  if (ro) ro.observe(host);
+  window.addEventListener('resize', function () { if (isOpen()) fitAll(); });
+
+  if (resizer) {
+    resizer.addEventListener('mousedown', function (e) {
+      e.preventDefault();
+      resizer.classList.add('resizing');
+      function move(ev) { applyHeight(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('--terminal-height'), 10);
+        if (cur) { try { localStorage.setItem(heightKey, String(cur)); } catch (e) {} }
+        fitAll();
+      }
+      document.addEventListener('mousemove', move);
+      document.addEventListener('mouseup', up);
+    });
+  }
+
+  // Kill this window's ptys on unload so a reload/close doesn't leak them in the main process.
+  window.addEventListener('beforeunload', function () {
+    panes.forEach(function (p) { if (p.id != null) { try { window.monacoriPty.kill({ id: p.id }); } catch (e) {} } });
+  });
+
+  // Hook for the merged-prompt modal: pipe the combined text into a chosen pane (no trailing Enter —
+  // the user reviews in the live session, then presses Enter, so multiline prompts stay intact).
+  function writeToPane(p, text) {
+    if (!p) return;
+    setOpen(true);
+    if (p.id != null) window.monacoriPty.write({ id: p.id, data: text });
+    setActive(p);
+    requestAnimationFrame(function () { try { p.term.focus(); } catch (e) {} });
+  }
+  // Pane-pick mode: triggered from the merged modal's "Send to terminal". The chosen pane is highlighted,
+  // the rest are dimmed; arrows change the pick, Enter sends, Esc cancels. Single pane → send at once.
+  var sendModeText = null, sendModeIdx = 0;
+  function paintSendMode() {
+    panes.forEach(function (p, i) {
+      p.el.classList.toggle('is-send-target', i === sendModeIdx);
+      p.el.classList.toggle('is-dimmed', i !== sendModeIdx);
+    });
+  }
+  function exitSendMode() {
+    if (sendModeText == null) return;
+    sendModeText = null;
+    panel.classList.remove('send-mode');
+    document.body.classList.remove('terminal-send-mode'); // un-dim the rest of the app
+    panes.forEach(function (p) { p.el.classList.remove('is-send-target', 'is-dimmed'); });
+  }
+  function enterSendMode(text) {
+    if (panes.length === 0) return;
+    setOpen(true);
+    sendModeText = text;
+    sendModeIdx = Math.max(0, panes.indexOf(active));
+    panel.classList.add('send-mode');
+    document.body.classList.add('terminal-send-mode'); // dim sidebar + file/diff view; only the terminal pops
+    paintSendMode();
+  }
+  // Capture phase so the pick keys win over the focused xterm; while picking, every key is swallowed.
+  document.addEventListener('keydown', function (e) {
+    if (sendModeText == null) return;
+    e.preventDefault(); e.stopPropagation();
+    if (e.key === 'ArrowLeft' || e.key === 'ArrowRight' || e.key === 'ArrowUp' || e.key === 'ArrowDown') {
+      var d = (e.key === 'ArrowRight' || e.key === 'ArrowDown') ? 1 : -1;
+      sendModeIdx = (sendModeIdx + d + panes.length) % panes.length;
+      paintSendMode();
+    } else if (e.key === 'Enter') {
+      var p = panes[sendModeIdx], text = sendModeText;
+      exitSendMode();
+      writeToPane(p, text);
+    } else if (e.key === 'Escape') {
+      exitSendMode();
+    }
+  }, true);
+  window.__monacoriTerminal = {
+    isOpen: isOpen,
+    open: function () { setOpen(true); },
+    paneCount: function () { return panes.length; },
+    enterSendMode: enterSendMode,
+    send: function (text) { writeToPane(active || panes[0], text); },
+    sendToPane: function (i, text) { writeToPane(panes[i] || active || panes[0], text); },
+    close: function () { setOpen(false); },
+  };
+
+  // Restore the open state across reloads.
+  try { if (sessionStorage.getItem(openKey) === '1') setOpen(true); } catch (e) {}
+})();
+
 // In Electron, the Review menu's Cmd/Ctrl+Shift+/ and +. accelerators arrive here via IPC
 // (macOS reserves Cmd+? for its Help search, so the menu claims it and routes to these views).
 if (window.monacoriMenu && typeof window.monacoriMenu.onMergedView === 'function') {
+  // Always open the merged-view modal; sending to a terminal pane is a button inside it (per-pane when
+  // split), so the user can pick which claude/codex session receives the prompt.
   window.monacoriMenu.onMergedView(function (kind) { openMergedView(kind); });
 }
+if (window.monacoriMenu && typeof window.monacoriMenu.onOpenMemo === 'function') {
+  // Cmd/Ctrl+Shift+N from the Review menu -> open/close the prompt memo.
+  window.monacoriMenu.onOpenMemo(function () { openMemoView(); });
+}
+if (window.monacoriMenu && typeof window.monacoriMenu.onDiffUpdate === 'function') {
+  // Electron watch: main rebuilds on working-tree changes and pushes the new HTML so we refresh the diff
+  // in place — NO window reload — keeping the integrated terminal's pty sessions (claude/codex) alive.
+  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).
+  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; }
+    if (isSourceViewerVisible()) closeActiveSourceTab();
+  });
+}
 
 (function checkForUpdate() {
   var current = window.__MONACORI_VERSION__ || '';
@@ -1873,9 +2417,19 @@ if (window.monacoriMenu && typeof window.monacoriMenu.onMergedView === 'function
     if (isNewer(latest, current)) {
       var flag = document.getElementById('app-update-flag');
       if (flag) flag.classList.remove('hidden');
-      if (status) { status.textContent = 'Update available: v' + latest; status.classList.add('has-update'); }
+      // One-click auto-update needs the Electron main process (it spawns npm). When available, reveal the
+      // button so a click installs + restarts; otherwise (browser/static export) name the command instead.
+      var ub = document.getElementById('app-info-update');
+      if (ub && window.monacoriUpdate && typeof window.monacoriUpdate.run === 'function') {
+        ub.textContent = t('settings.updateRestart') + ' (v' + latest + ')';
+        ub.classList.remove('hidden');
+        if (status) { status.textContent = t('settings.updateAvailable') + ': v' + latest; status.classList.add('has-update'); }
+      } else if (status) {
+        status.textContent = t('settings.updateAvailable') + ': v' + latest + ' — npm i -g @happy-nut/monacori';
+        status.classList.add('has-update');
+      }
     } else if (status) {
-      status.textContent = 'Up to date (v' + current + ')';
+      status.textContent = t('settings.upToDate') + ' (v' + current + ')';
     }
   };
   // Cache the npm result for the session so watch-mode reloads reuse it instead of refetching.
@@ -1893,28 +2447,81 @@ if (window.monacoriMenu && typeof window.monacoriMenu.onMergedView === 'function
     .catch(function () {});
 })();
 
-(function setupAppInfo() {
-  var btn = document.getElementById('app-info-btn');
-  var panel = document.getElementById('app-info');
+// Unified settings modal: the sidebar-footer gear opens it (General category by default), with
+// About/update/shortcuts under General and the merge-prompt editor under Merge prompts.
+(function setupSettings() {
+  var modal = document.getElementById('settings-modal');
+  if (!modal) return;
+  var gearBtn = document.getElementById('app-info-btn');
   var flag = document.getElementById('app-update-flag');
-  var copyBtn = document.getElementById('app-info-copy');
-  if (!btn || !panel) return;
-  var setOpen = function (open) { panel.classList.toggle('hidden', !open); };
-  btn.addEventListener('click', function (e) { e.stopPropagation(); setOpen(panel.classList.contains('hidden')); });
-  if (flag) flag.addEventListener('click', function (e) { e.stopPropagation(); setOpen(true); });
-  if (copyBtn) copyBtn.addEventListener('click', function () {
-    var cmd = 'npm i -g @happy-nut/monacori';
-    var done = function () { copyBtn.textContent = 'Copied'; setTimeout(function () { copyBtn.textContent = 'Copy'; }, 1200); };
-    if (navigator.clipboard && navigator.clipboard.writeText) { navigator.clipboard.writeText(cmd).then(done).catch(function () {}); }
-  });
-  document.addEventListener('click', function (e) {
-    if (panel.classList.contains('hidden')) return;
-    if (panel.contains(e.target) || btn.contains(e.target)) return;
-    setOpen(false);
-  });
+  var updateBtn = document.getElementById('app-info-update');
+  var qta = document.getElementById('settings-prompt-q');
+  var cta = document.getElementById('settings-prompt-c');
+  var resetBtn = document.getElementById('settings-reset');
+  var savedMsg = document.getElementById('settings-saved');
+  var cats = Array.prototype.slice.call(modal.querySelectorAll('.settings-cat'));
+  var secs = Array.prototype.slice.call(modal.querySelectorAll('.settings-section'));
+  function showCat(cat) {
+    cats.forEach(function (c) { c.classList.toggle('active', c.dataset.cat === cat); });
+    secs.forEach(function (s) { s.classList.toggle('hidden', s.dataset.cat !== cat); });
+  }
+  function fill() {
+    var s = loadMergePrompts();
+    if (qta) { qta.value = typeof s.q === 'string' ? s.q : ''; qta.placeholder = defaultMergePrompt('q'); }
+    if (cta) { cta.value = typeof s.c === 'string' ? s.c : ''; cta.placeholder = defaultMergePrompt('c'); }
+  }
+  function open(cat) { fill(); if (cat) showCat(cat); modal.classList.remove('hidden'); }
+  function close() { modal.classList.add('hidden'); }
+  var flashTimer = null;
+  function flash() { if (!savedMsg) return; savedMsg.textContent = 'Saved'; if (flashTimer) clearTimeout(flashTimer); flashTimer = setTimeout(function () { savedMsg.textContent = ''; }, 1200); }
+  if (gearBtn) gearBtn.addEventListener('click', function (e) { e.stopPropagation(); if (modal.classList.contains('hidden')) open('general'); else close(); });
+  if (flag) flag.addEventListener('click', function (e) { e.stopPropagation(); open('general'); });
+  cats.forEach(function (c) { c.addEventListener('click', function () { showCat(c.dataset.cat); }); });
+  modal.addEventListener('click', function (e) { if (e.target === modal) close(); });
+  // Capture so closing settings wins over other Escape handlers (lightbox / composer).
   document.addEventListener('keydown', function (e) {
-    if (e.key === 'Escape' && !panel.classList.contains('hidden')) setOpen(false);
-  });
+    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.
+    if ((e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey && (e.key === ',' || e.code === 'Comma')) {
+      e.preventDefault(); e.stopPropagation();
+      if (modal.classList.contains('hidden')) open('general'); else close();
+    }
+  }, true);
+  // One-click self-update (Electron only): install latest globally via the main process, then relaunch.
+  if (updateBtn && window.monacoriUpdate && typeof window.monacoriUpdate.run === 'function') {
+    updateBtn.addEventListener('click', function () {
+      if (updateBtn.disabled) return;
+      updateBtn.disabled = true;
+      var status = document.getElementById('app-info-status');
+      if (status) { status.textContent = t('settings.updating'); status.classList.add('has-update'); }
+      window.monacoriUpdate.run().then(function (r) {
+        if (r && r.ok) { if (status) status.textContent = t('settings.updated'); }
+        else { updateBtn.disabled = false; if (status) status.textContent = t('settings.updateFailed'); }
+      }).catch(function () { updateBtn.disabled = false; if (status) status.textContent = t('settings.updateFailed'); });
+    });
+  }
+  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(); });
+  // 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.
+  var langSel = document.getElementById('settings-language');
+  if (langSel) {
+    langSel.value = locale;
+    langSel.addEventListener('change', function () {
+      var next = langSel.value === 'ko' ? 'ko' : 'en';
+      if (next === locale) return;
+      locale = next;
+      persistSave(LOCALE_KEY, locale);
+      applyI18n();
+      // Merge-prompt placeholders are locale-dependent defaults; refresh them while the panel is open.
+      fill();
+      // Re-render dynamic, currently-visible text in the new locale.
+      try { if (typeof refreshComments === 'function') refreshComments(); } catch (e) {}
+      var mergedModal = document.getElementById('mc-modal');
+      if (mergedModal) { var mk = mergedModal.dataset.kind || 'q'; mergedModal.remove(); openMergedView(mk); }
+    });
+  }
 })();
 
 function setTab(name) {
@@ -1933,7 +2540,7 @@ function ensureTreeRendered() {
   if (!panel || !island) return;
   var html = island.textContent || '';
   island.parentNode && island.parentNode.removeChild(island);
-  panel.innerHTML = '<div class="empty-nav">Building file tree…</div>';
+  panel.innerHTML = '<div class="empty-nav">' + escapeHtml(t('source.buildingTree')) + '</div>';
   setTimeout(function () { // let "Building…" paint before the heavy innerHTML
     panel.innerHTML = html;
     sourceLinks = Array.from(document.querySelectorAll('.source-link'));
@@ -1975,6 +2582,11 @@ function saveUiState() {
     view: document.getElementById('source-viewer')?.classList.contains('hidden') ? 'diff' : 'source',
     sourcePath,
     hash: location.hash,
+    // Preserve open tabs + the exact caret across watch reloads (otherwise the caret resets to the
+    // hunk's first change / file top every time the working tree changes).
+    tabs: sourceTabs,
+    diffCursor: diffCursor,
+    viewerCursor: viewerCursor,
   }));
 }
 
@@ -1983,13 +2595,25 @@ function restoreUiState() {
   if (!raw) return false;
   try {
     const state = JSON.parse(raw);
+    // Restore Files-mode tabs first so a watch reload doesn't drop the open tabs.
+    if (Array.isArray(state.tabs)) sourceTabs = state.tabs.filter(function (p) { return sourceByPath.has(p); });
     if (state.view === 'diff') {
-      const match = String(state.hash || location.hash || '').match(/^#hunk-(\\d+)$/);
+      const match = String(state.hash || location.hash || '').match(/^#hunk-(\d+)$/);
       setActive(match ? Number(match[1]) : current >= 0 ? current : 0, false);
+      // Restore the exact diff caret (setActive only lands on the hunk's first change).
+      if (state.diffCursor && state.diffCursor.path) {
+        var dc = state.diffCursor;
+        setTimeout(function () { try { setDiffCursor(dc.path, dc.side, dc.rowIndex, dc.column, true); } catch (e) {} }, 60);
+      }
       return true;
     }
     if (state.sourcePath && sourceByPath.has(state.sourcePath)) {
       openSourceFile(state.sourcePath);
+      // Restore the exact source caret/scroll (openSourceFile alone resets it to the top).
+      if (state.viewerCursor && state.viewerCursor.path === state.sourcePath) {
+        var vc = state.viewerCursor;
+        setTimeout(function () { try { setSourceCursor(state.sourcePath, vc.lineIndex, vc.column, true, -1); } catch (e) {} }, 60);
+      }
       return true;
     }
   } catch {
@@ -1998,6 +2622,71 @@ function restoreUiState() {
   return false;
 }
 
+// In-place diff refresh (instead of a full window reload): apply a compact payload of just the changed
+// 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.
+function applyDiffUpdate(u) {
+  if (!u || !u.signature || u.signature === currentSignature) return false; // unchanged — nothing to do
+
+  // Remember what to restore after the swap (comments/viewed persist on their own; these don't).
+  var sv = document.getElementById('source-viewer');
+  var openPath = (sv && sv.dataset.openPath) || '';
+  var wasSource = isSourceViewerVisible();
+  var container = document.getElementById('diff2html-container');
+  var diffScrollTop = container ? container.scrollTop : 0;
+
+  // 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');
+  if (changesPanel) changesPanel.innerHTML = u.changesPanel || '';
+  // Files tree: keep the inert island (lazy, not yet opened) in sync, and refresh the live panel when it's
+  // already materialized — or always, in eager mode where the panel holds the tree directly.
+  var filesIsland = document.getElementById('files-tree-html');
+  if (filesIsland) filesIsland.textContent = u.filesTree || '';
+  var filesPanel = document.getElementById('files-panel');
+  if (filesPanel && (!REVIEW_LAZY || filesPanel.innerHTML.trim())) filesPanel.innerHTML = u.filesTree || '';
+  var statusEl = document.querySelector('.review-status');
+  if (statusEl) statusEl.innerHTML = u.reviewStatus || '';
+  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.
+  fileStates = u.fileStates || [];
+  fileSignatureByPath = new Map(fileStates.map(function (f) { return [f.path, f.signature]; }));
+  sourceFiles = u.sourceFilesMeta || [];
+  sourceByPath = new Map(sourceFiles.map(function (f) { return [f.path, f]; }));
+  httpEnvironments = u.httpEnvironments || {};
+  httpEnvNames = Object.keys(httpEnvironments);
+  currentSignature = u.signature;
+  links = Array.from(document.querySelectorAll('#changes-panel .file-link'));
+  sourceLinks = Array.from(document.querySelectorAll('.source-link'));
+
+  // 3) Reset lazy-materialize + index state so the new diff bodies / source / symbols rebuild on demand.
+  bodyPromise = {};
+  diffBootDone = false;
+  sourceLoaded = !REVIEW_LAZY_LOAD; // lazyLoad: re-fetch source content on next use
+  sourceLoading = false;
+  symbolIndex = null;
+  if (REVIEW_LAZY) { setupLazyDiff(); setTimeout(function () { diffBootDone = true; }, 0); }
+  else { prepareDiff2HtmlHunks(); diffBootDone = true; }
+  if (!REVIEW_LAZY_LOAD) setTimeout(startSymbolIndex, 0);
+
+  // 4) Re-run the DOM-dependent bootstrap steps.
+  applyI18n();
+  populateHttpEnvSelect();
+  initSourceTreeFolds();
+  refreshComments();
+
+  // 5) Best-effort restore of what the user was looking at.
+  if (wasSource && openPath && sourceByPath.has(openPath)) {
+    openSourceFile(openPath, false);
+  } else if (container) {
+    showDiffView(false);
+    container.scrollTop = diffScrollTop;
+  }
+  return true;
+}
+
 async function checkForLiveUpdate() {
   if (checkingForUpdates) return;
   checkingForUpdates = true;
@@ -2007,14 +2696,18 @@ async function checkForLiveUpdate() {
     if (!response.ok) return;
     const state = await response.json();
     if (liveStatus && state.generatedAt) {
-      liveStatus.textContent = 'Live: updated ' + new Date(state.generatedAt).toLocaleTimeString();
+      liveStatus.textContent = t('status.live.updated') + ' ' + new Date(state.generatedAt).toLocaleTimeString();
     }
     if (state.signature && state.signature !== currentSignature) {
-      saveUiState();
-      location.reload();
+      // serve mode: fetch just the compact update payload and refresh in place (same path Electron uses
+      // over IPC) rather than reloading — so an open integrated terminal keeps its sessions.
+      try {
+        var fresh = await fetch('__ai_flow_update', { cache: 'no-store' });
+        if (fresh.ok) applyDiffUpdate(await fresh.json());
+      } catch (e) {}
     }
   } catch {
-    if (liveStatus) liveStatus.textContent = 'Live: waiting for diff server';
+    if (liveStatus) liveStatus.textContent = t('status.live.waiting');
   } finally {
     checkingForUpdates = false;
   }
@@ -2190,7 +2883,18 @@ function measureCharWidth(element) {
   return measuredCharWidth;
 }
 
+var caretBusyTimer = null;
+// While the caret is actively moving (held arrow key, typing), keep it solid and only resume the
+// blink animation after a short idle. Otherwise key-repeat exposes the blink's "off" frames between
+// moves and the caret appears to vanish intermittently.
+function markCaretBusy() {
+  document.body.classList.add('caret-busy');
+  if (caretBusyTimer) clearTimeout(caretBusyTimer);
+  caretBusyTimer = setTimeout(function () { document.body.classList.remove('caret-busy'); }, 650);
+}
+
 function setSourceCursor(path, lineIndex, column, shouldReveal = false, targetLine = -1) {
+  markCaretBusy();
   selectedCommentRow = null; // any explicit caret placement (click/move) ends a comment-box selection
   const file = sourceByPath.get(path);
   if (!file || !file.embedded) return;
@@ -2229,14 +2933,19 @@ function setSourceCursor(path, lineIndex, column, shouldReveal = false, targetLi
 function updateSourceCaret(prev, lines, language) {
   const body = document.getElementById('source-body');
   if (!body) return;
+  // Markdown/CSV render to HTML cells (.rendered-body): the caret is a whole-row highlight there,
+  // so never rewrite a cell's innerHTML (that would replace the rendered block with raw text).
+  const rendered = body.classList.contains('rendered-body');
   const rowFor = (idx) => body.querySelector('.source-row[data-line-index="' + idx + '"]');
   // Restore the line the caret left: drop the caret span, re-highlight the full line.
   if (prev && prev.lineIndex !== viewerCursor.lineIndex) {
     const prevRow = rowFor(prev.lineIndex);
     if (prevRow) {
       prevRow.classList.remove('cursor-line');
-      const prevCell = prevRow.querySelector('.source-code');
-      if (prevCell) prevCell.innerHTML = highlightLine(lines[prev.lineIndex] || '', language);
+      if (!rendered) {
+        const prevCell = prevRow.querySelector('.source-code');
+        if (prevCell) prevCell.innerHTML = highlightLine(lines[prev.lineIndex] || '', language);
+      }
     }
   }
   // Reconcile the go-to-definition highlight (set only on symbol jumps, cleared on plain moves).
@@ -2244,10 +2953,12 @@ function updateSourceCaret(prev, lines, language) {
   if (viewerCursor.targetLine >= 0) rowFor(viewerCursor.targetLine)?.classList.add('symbol-target');
   // Rebuild the new caret line with the caret span.
   const row = rowFor(viewerCursor.lineIndex);
-  if (!row) { openSourceFile(viewerCursor.path, false); return; } // line not in the DOM — fall back to a full render
+  if (!row) { if (!rendered) openSourceFile(viewerCursor.path, false); return; } // line not in the DOM — full re-render (eager source only)
   row.classList.add('cursor-line');
-  const cell = row.querySelector('.source-code');
-  if (cell) cell.innerHTML = renderLineWithCursor(lines[viewerCursor.lineIndex] || '', language, viewerCursor.column);
+  if (!rendered) {
+    const cell = row.querySelector('.source-code');
+    if (cell) cell.innerHTML = renderLineWithCursor(lines[viewerCursor.lineIndex] || '', language, viewerCursor.column);
+  }
 }
 
 function openSourceAt(path, lineIndex, column) {
@@ -2351,6 +3062,20 @@ function moveSourceCursor(dLine, dColumn, extend) {
   if (!viewerCursor) return;
   const file = sourceByPath.get(viewerCursor.path);
   if (!file || !file.embedded) return;
+  // Markdown/CSV rendered view: rows are blocks (sparse data-line-index), so any arrow steps to the
+  // adjacent block row rather than into a (non-existent) raw line. No text column / selection there.
+  const renderedBody = document.getElementById('source-body');
+  if (renderedBody && renderedBody.classList.contains('rendered-body')) {
+    const rows = Array.from(renderedBody.querySelectorAll('.source-row'));
+    if (!rows.length) return;
+    let ci = rows.indexOf(renderedBody.querySelector('.source-row[data-line-index="' + viewerCursor.lineIndex + '"]'));
+    if (ci < 0) ci = 0;
+    const step = (dLine || 0) + (dColumn > 0 ? 1 : dColumn < 0 ? -1 : 0);
+    const ni = Math.max(0, Math.min(rows.length - 1, ci + (step || 0)));
+    selectionAnchor = null;
+    setSourceCursor(viewerCursor.path, Number(rows[ni].dataset.lineIndex) || 0, 0, true, -1);
+    return;
+  }
   const lines = file.content.split(/\r?\n/);
   let line = viewerCursor.lineIndex;
   let col = viewerCursor.column;
@@ -2599,6 +3324,14 @@ function symbolIndexWorker() {
     self.postMessage({ index: index, total: total });
   };
 }
+// Run symbol indexing off the critical path: requestIdleCallback so the heavy postMessage of the whole
+// source blob to the worker (structured-clone serialization is synchronous on the main thread) never
+// competes with key handling — especially on big repos right after the diff/tree first paints.
+function scheduleSymbolIndex() {
+  var run = function () { try { startSymbolIndex(); } catch (e) {} };
+  if (typeof window !== 'undefined' && typeof window.requestIdleCallback === 'function') window.requestIdleCallback(run, { timeout: 3000 });
+  else setTimeout(run, 0);
+}
 function startSymbolIndex() {
   try {
     if (typeof Worker === 'undefined' || typeof Blob === 'undefined' || typeof URL === 'undefined' || !URL.createObjectURL) return;
@@ -2631,11 +3364,11 @@ function setIndexProgress(done, total) {
   var bar = document.getElementById('index-progress');
   if (!el) return;
   if (!total || done >= total) {
-    el.textContent = (total || 0) + ' indexed';
+    el.textContent = (total || 0) + ' ' + t('status.indexed');
     if (bar) bar.classList.add('hidden');
     return;
   }
-  el.textContent = 'indexing ' + done + '/' + total + '…';
+  el.textContent = t('status.indexing') + ' ' + done + '/' + total + '…';
   if (bar) {
     bar.classList.remove('hidden');
     var fill = bar.firstElementChild;
@@ -2712,9 +3445,56 @@ function setSourceTypeIcon(path) {
   var icon = link ? link.querySelector('.ftype') : null;
   holder.innerHTML = icon ? icon.outerHTML : '';
 }
+// Files-mode tabs: each distinct file opened in the source viewer becomes a tab (session-only).
+// Cmd/Ctrl+W closes the active tab; Cmd/Ctrl+Shift+[ / ] cycle tabs; the × button closes one.
+// (sourceTabs is declared near the other source state up top so early restore-state openSourceFile
+// calls run before this block don't see an undefined array.)
+function addSourceTab(path) { if (path && sourceTabs.indexOf(path) < 0) sourceTabs.push(path); }
+function sourceTabLabel(path) { var p = String(path || ''); var s = p.lastIndexOf('/'); return s >= 0 ? p.slice(s + 1) : p; }
+function currentSourceTabPath() { var v = document.getElementById('source-viewer'); return (v && v.dataset.openPath) || ''; }
+function renderSourceTabs(activePath) {
+  var bar = document.getElementById('source-tabs');
+  if (!bar) return;
+  if (!sourceTabs.length) { bar.classList.add('hidden'); bar.innerHTML = ''; return; }
+  bar.classList.remove('hidden');
+  bar.innerHTML = sourceTabs.map(function (p) {
+    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>'
+      + '</div>';
+  }).join('');
+  var act = bar.querySelector('.source-tab.active');
+  if (act && act.scrollIntoView) act.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+}
+function closeSourceTab(path) {
+  var idx = sourceTabs.indexOf(path);
+  if (idx < 0) return;
+  var wasActive = path === currentSourceTabPath();
+  sourceTabs.splice(idx, 1);
+  if (!wasActive) { renderSourceTabs(currentSourceTabPath()); return; }
+  var nextPath = sourceTabs[idx] || sourceTabs[idx - 1] || '';
+  if (nextPath) { openSourceFile(nextPath); return; }
+  // No tabs left: reset the source view to its empty state.
+  var v = document.getElementById('source-viewer'); if (v) v.dataset.openPath = '';
+  var body = document.getElementById('source-body');
+  if (body) { body.className = 'source-body empty'; body.textContent = t('source.selectFile'); }
+  sourceLinks.forEach(function (l) { l.classList.remove('active'); });
+  renderSourceTabs('');
+}
+function closeActiveSourceTab() { var p = currentSourceTabPath(); if (p) { closeSourceTab(p); return true; } return false; }
+function cycleSourceTab(dir) {
+  if (sourceTabs.length < 2) return;
+  var cur = sourceTabs.indexOf(currentSourceTabPath());
+  if (cur < 0) cur = 0;
+  openSourceFile(sourceTabs[(cur + dir + sourceTabs.length) % sourceTabs.length]);
+}
+
 function openSourceFile(path, shouldSwitch = true) {
   const file = sourceByPath.get(path);
   if (!file) return;
+  addSourceTab(path);
+  renderSourceTabs(path);
   // lazy-LOAD: source content not fetched yet -> show a loading state; loadSourceData re-opens it.
   if (REVIEW_LAZY_LOAD && !sourceLoaded && file.embedded) {
     pendingSourceOpen = { path: path, shouldSwitch: shouldSwitch };
@@ -2726,7 +3506,7 @@ function openSourceFile(path, shouldSwitch = true) {
     revealTreeFor(path);
     var lb = document.getElementById('source-body');
     lb.className = 'source-body empty';
-    lb.textContent = 'Loading source…';
+    lb.textContent = t('source.loading');
     if (shouldSwitch) showSourceView();
     return;
   }
@@ -2736,12 +3516,9 @@ function openSourceFile(path, shouldSwitch = true) {
   renderBreadcrumb(document.getElementById('source-title'), path);
   setSourceTypeIcon(path);
   revealTreeFor(path);
-  const meta = [
-    file.language || 'text',
-    formatBytes(file.size || 0),
-    file.changed ? 'changed' : 'unchanged',
-    file.embedded ? 'searchable' : file.skippedReason || 'not embedded',
-  ].join(' | ');
+  const meta = file.embedded
+    ? formatBytes(file.size || 0)
+    : formatBytes(file.size || 0) + ' · ' + (file.skippedReason || 'not embedded');
   document.getElementById('source-meta').textContent = meta;
   const body = document.getElementById('source-body');
   // Image files carry a data: URI preview instead of text — render inline (click to zoom).
@@ -2755,7 +3532,7 @@ function openSourceFile(path, shouldSwitch = true) {
   }
   if (!file.embedded) {
     body.className = 'source-body empty';
-    body.textContent = file.skippedReason ? 'Source preview unavailable: ' + file.skippedReason + '.' : 'Source preview unavailable.';
+    body.textContent = file.skippedReason ? t('source.previewUnavailable').replace(/\.$/, '') + ': ' + file.skippedReason + '.' : t('source.previewUnavailable');
     document.getElementById('http-env-select')?.classList.add('hidden');
     updateRenderToggle(path);
     if (shouldSwitch) showSourceView();
@@ -2770,17 +3547,27 @@ function openSourceFile(path, shouldSwitch = true) {
   // is a .source-row keyed by its start line, so the gutter shows line numbers and line/block comments
   // work exactly as in the plain source view (renderSourceComments anchors on .source-row[data-line-index]).
   if (isMarkdownPath(path)) {
-    body.classList.add('rendered-body');
-    body.innerHTML = renderMarkdownRows(file.content);
+    if (renderRawMode) {
+      body.innerHTML = renderSourceTable(file, '');
+    } else {
+      body.classList.add('rendered-body');
+      body.innerHTML = renderMarkdownRows(file.content);
+    }
     if (httpEnvSelect) httpEnvSelect.classList.add('hidden');
+    updateRenderToggle(path);
     renderSourceComments();
     if (shouldSwitch) showSourceView();
     return;
   }
   if (isCsvPath(path)) {
-    body.classList.add('rendered-body');
-    body.innerHTML = renderCsvRows(file.content, path);
+    if (renderRawMode) {
+      body.innerHTML = renderSourceTable(file, '');
+    } else {
+      body.classList.add('rendered-body');
+      body.innerHTML = renderCsvRows(file.content, path);
+    }
     if (httpEnvSelect) httpEnvSelect.classList.add('hidden');
+    updateRenderToggle(path);
     renderSourceComments();
     if (shouldSwitch) showSourceView();
     return;
@@ -2792,12 +3579,45 @@ function openSourceFile(path, shouldSwitch = true) {
     body.innerHTML = renderSourceTable(file, '');
     if (httpEnvSelect) httpEnvSelect.classList.add('hidden');
   }
+  updateRenderToggle(path);
   renderSourceComments();
   if (shouldSwitch) showSourceView();
 }
 
 function isMarkdownPath(p) { return /\.(md|mdx|markdown)$/i.test(p || ''); }
 function isCsvPath(p) { return /\.(csv|tsv)$/i.test(p || ''); }
+function isRenderToggleable(p) { return isMarkdownPath(p) || isCsvPath(p); }
+
+// Markdown/CSV open rendered by default; this flips the open file to raw line-numbered text and back.
+// Session-global so the choice carries across files. The toolbar button + Cmd/Ctrl+Shift+M both call it.
+var renderRawMode = false;
+function updateRenderToggle(path) {
+  var btn = document.getElementById('render-toggle');
+  if (!btn) return;
+  var on = isRenderToggleable(path);
+  btn.classList.toggle('hidden', !on);
+  if (!on) return;
+  btn.textContent = renderRawMode ? t('source.viewRendered') : t('source.viewRaw'); // label = the mode you switch TO
+  btn.setAttribute('aria-pressed', renderRawMode ? 'true' : 'false');
+}
+function toggleRenderMode() {
+  var sv = document.getElementById('source-viewer');
+  var open = sv && sv.dataset.openPath;
+  if (!open || !isRenderToggleable(open)) return;
+  renderRawMode = !renderRawMode;
+  openSourceFile(open, false); // re-render the current file in the new mode
+}
+(function wireRenderToggle() {
+  var btn = document.getElementById('render-toggle');
+  if (btn) btn.addEventListener('click', function () { toggleRenderMode(); });
+  document.addEventListener('keydown', function (e) {
+    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;
+      if (open && isRenderToggleable(open) && isSourceViewerVisible()) { e.preventDefault(); toggleRenderMode(); }
+    }
+  });
+})();
 
 function renderImageView(file) {
   return '<div class="image-view">'
@@ -3218,16 +4038,21 @@ function populateHttpEnvSelect() {
     opts += '<option value="' + escapeHtml(name) + '"' + (name === currentHttpEnvName ? ' selected' : '') + '>' + escapeHtml(name) + '</option>';
   });
   select.innerHTML = opts;
-  select.addEventListener('change', function () {
-    currentHttpEnvName = select.value;
-    try { localStorage.setItem(httpEnvKey, currentHttpEnvName); } catch (error) {}
-    const path = document.getElementById('source-viewer')?.dataset.openPath || '';
-    if (path && isHttpFile(path)) {
-      const file = sourceByPath.get(path);
-      const body = document.getElementById('source-body');
-      if (file && body) body.innerHTML = renderHttpTable(file);
-    }
-  });
+  // The <select> lives in the toolbar (not swapped on in-place diff updates), so wire the change handler
+  // exactly once — populateHttpEnvSelect is re-called by applyDiffUpdate to refresh the options.
+  if (!select.dataset.wired) {
+    select.dataset.wired = '1';
+    select.addEventListener('change', function () {
+      currentHttpEnvName = select.value;
+      try { localStorage.setItem(httpEnvKey, currentHttpEnvName); } catch (error) {}
+      const path = document.getElementById('source-viewer')?.dataset.openPath || '';
+      if (path && isHttpFile(path)) {
+        const file = sourceByPath.get(path);
+        const body = document.getElementById('source-body');
+        if (file && body) body.innerHTML = renderHttpTable(file);
+      }
+    });
+  }
 }
 
 function renderSourceTable(file, query) {