@fresh-editor/fresh-editor 0.3.6 → 0.3.7

package/plugins/lib/widgets.ts

@@ -46,7 +46,7 @@ export type WidgetAction = globalThis.WidgetAction;
 export type WidgetMutation = globalThis.WidgetMutation;
 export type TreeNode = globalThis.TreeNode;
 export type StyledSegment = globalThis.StyledSegment;
-type TextPropertyEntry = globalThis.TextPropertyEntry;
+export type TextPropertyEntry = globalThis.TextPropertyEntry;
 type InlineOverlay = globalThis.InlineOverlay;
 type OverlayOptions = globalThis.OverlayOptions;
 
@@ -77,8 +77,8 @@ export function hintBar(entries: HintEntry[]): WidgetSpec {
  * `TextPropertyEntry[]` (the same shape `setVirtualBufferContent`
  * already accepts) so a plugin can migrate its panel one widget at a
  * time. */
-export function raw(entries: TextPropertyEntry[]): WidgetSpec {
- return { kind: "raw", entries };
+export function raw(entries: TextPropertyEntry[], key?: string): WidgetSpec {
+  return { kind: "raw", entries, key };
 }
 
 /** Build a `TextPropertyEntry` from a sequence of styled segments.
@@ -142,13 +142,20 @@ export function toggle(
 
 /** Action button, rendered as `[ Label ]`. `intent` controls visual
  * emphasis: `"normal"` (default) → no override, `"primary"` → bold,
- * `"danger"` → error theme key. */
+ * `"danger"` → error theme key.
+ *
+ * `disabled: true` paints the button with `ui.menu_disabled_fg`,
+ * drops it from the Tab cycle, and makes clicks no-ops — for actions
+ * that aren't currently available against the surrounding state.
+ * The button still occupies its layout cell, so flipping `disabled`
+ * doesn't reshuffle the surrounding row. */
 export function button(
   label: string,
   options?: {
     focused?: boolean;
     intent?: ButtonKind;
     key?: string;
+    disabled?: boolean;
   },
 ): WidgetSpec {
   return {
@@ -157,6 +164,7 @@ export function button(
     focused: options?.focused ?? false,
     intent: options?.intent ?? "normal",
     key: options?.key,
+    disabled: options?.disabled ?? false,
   };
 }
 
@@ -339,6 +347,13 @@ export function text(
      * with `labeledSection(...)` to get a uniformly full-width
      * fieldset look. */
     fullWidth?: boolean;
+    /** Initial completion candidates. Use the
+     * `setCompletions(widgetKey, items)` mutation for live
+     * updates — the spec field seeds the host's instance state
+     * on first render only. Empty = no popup. See
+     * `WidgetSpec::Text.completions` (Rust) for the rendering
+     * + keyboard semantics. */
+    completions?: string[];
     key?: string;
   } = {},
 ): WidgetSpec {
@@ -353,6 +368,7 @@ export function text(
     fieldWidth: options.fieldWidth ?? 0,
     maxVisibleChars: options.maxVisibleChars ?? 0,
     fullWidth: options.fullWidth ?? false,
+    completions: options.completions ?? [],
     key: options.key,
   };
 }
@@ -472,6 +488,30 @@ export function labeledSection(options: {
   };
 }
 
+/** Float `child` over the rest of the layout instead of consuming
+ * vertical space. Place inside a `Col` at the position where you
+ * want the overlay to anchor — at paint time the child renders
+ * at that row but DOES NOT push the rows below it down. Used for
+ * dropdown completions, tooltips, hover popups — anything that
+ * should appear next to a focused widget without reflowing the
+ * panel each time it shows or hides.
+ *
+ * Hit-testing: overlays paint on top, so clicks inside the
+ * overlay's region go to the overlay (not what's underneath).
+ * Tab cycle: the child IS walked for tabbable keys — give it a
+ * `key` if you want focus to reach it, or leave it keyless to
+ * keep it out of the cycle (the typical popup case). */
+export function overlay(
+  child: WidgetSpec,
+  options?: { key?: string },
+): WidgetSpec {
+  return {
+    kind: "overlay",
+    child,
+    key: options?.key,
+  };
+}
+
 // =============================================================================
 // HintEntry parsing — for the legacy `Tab:section  Esc:close` format
 // shipped in existing plugin i18n bundles.
@@ -593,6 +633,18 @@ export class WidgetPanel {
     return this.mutate({ kind: "setSelectedIndex", widgetKey, index });
   }
 
+  /** Update a Text widget's completion popup candidates. Empty
+   * `items` closes the popup; non-empty opens it and resets the
+   * host-managed selection to index 0. The host repaints the
+   * popup on its own; the plugin doesn't need to follow up with
+   * an `update(spec)` call. */
+  setCompletions(
+    widgetKey: string,
+    items: Array<string | { value: string; kind?: string }>,
+  ): boolean {
+    return this.mutate({ kind: "setCompletions", widgetKey, items });
+  }
+
   /** Replace a `List`'s items + parallel `itemKeys`. */
   setItems(
     widgetKey: string,
@@ -618,6 +670,44 @@ export class WidgetPanel {
   setCheckedKeys(widgetKey: string, checked: boolean, keys: string[]): boolean {
     return this.mutate({ kind: "setCheckedKeys", widgetKey, checked, keys });
   }
+
+  /** Append `newNodes` (and parallel `newItemKeys`) to an existing
+   * `Tree`'s node list — the streaming-friendly counterpart to
+   * `setItems`. Existing selection, scroll, and expansion state are
+   * preserved; the renderer simply has more tail to paint on the next
+   * cycle. Cheap relative to a full spec re-emit for plugins that
+   * stream large result sets (e.g. a project-wide grep). */
+  appendTreeNodes(
+    widgetKey: string,
+    newNodes: TreeNode[],
+    newItemKeys: string[] = [],
+  ): boolean {
+    return this.mutate({
+      kind: "appendTreeNodes",
+      widgetKey,
+      newNodes,
+      newItemKeys,
+    });
+  }
+
+  /** Replace the entries of a `Raw` widget identified by `widgetKey`.
+   *
+   * Use this when a small piece of panel chrome (a label, a header,
+   * a status line) needs to change but the rest of the spec is
+   * unchanged — calling `set(...)` to push the whole spec just to
+   * flip a few characters would force a `js_to_json` walk of every
+   * other widget (and every `Tree` node) in the panel, which can
+   * block the JS thread for hundreds of ms on large panels. */
+  setRawEntries(widgetKey: string, entries: TextPropertyEntry[]): boolean {
+    return this.mutate({ kind: "setRawEntries", widgetKey, entries });
+  }
+
+  /** Set the panel's focused widget by key. Passing a key that isn't
+   * a current tabbable is harmless — the next render clamps focus to
+   * the first tabbable. */
+  setFocusKey(widgetKey: string): boolean {
+    return this.mutate({ kind: "setFocusKey", widgetKey });
+  }
 }
 
 // =============================================================================
@@ -715,6 +805,16 @@ export class FloatingWidgetPanel {
     return this.mutate({ kind: "setSelectedIndex", widgetKey, index });
   }
 
+  /** Update a Text widget's completion popup candidates. Empty
+   * `items` closes the popup; non-empty opens it and resets the
+   * host-managed selection to index 0. */
+  setCompletions(
+    widgetKey: string,
+    items: Array<string | { value: string; kind?: string }>,
+  ): boolean {
+    return this.mutate({ kind: "setCompletions", widgetKey, items });
+  }
+
   setItems(
     widgetKey: string,
     items: TextPropertyEntry[],
@@ -730,6 +830,13 @@ export class FloatingWidgetPanel {
   setCheckedKeys(widgetKey: string, checked: boolean, keys: string[]): boolean {
     return this.mutate({ kind: "setCheckedKeys", widgetKey, checked, keys });
   }
+
+  /** Set the panel's focused widget by key. Passing a key that isn't
+   * a current tabbable is harmless — the next render clamps focus to
+   * the first tabbable. */
+  setFocusKey(widgetKey: string): boolean {
+    return this.mutate({ kind: "setFocusKey", widgetKey });
+  }
 }
 
 // =============================================================================

package/plugins/live_diff.ts

@@ -73,19 +73,22 @@ const DEBOUNCE_MS = 75;
 
 // Skip virtual-line rendering when either side is huge — line-by-line
 // LCS would be too slow. Gutter glyphs still render via a degraded path.
-const MAX_DIFF_LINES = 20_000;
-// Soft cap on the LCS DP table; past this we stop computing virtual lines.
-const MAX_DP_CELLS = 4_000_000;
+// In practice the DP only runs over the diff's *middle* (common prefix
+// and suffix are stripped first), so this cap rarely bites for typical
+// "small edit to a large file" cases.
+const MAX_DIFF_LINES = 100_000;
+// Soft cap on the LCS DP table; past this we stop computing virtual
+// lines. Applies to the post-prefix/suffix-stripped middle, not the
+// whole file.
+const MAX_DP_CELLS = 16_000_000;
 
 // Similarity (Sørensen–Dice over character LCS) above which a 1:1
 // modified pair is rendered as "modified" (bg-only highlight on the
 // new line, no deletion virtual line). Below this we split the pair
 // into a `removed` (virtual deletion line) + `added` (bg-highlighted)
 // hunk pair so the change reads as a rewrite, not an in-place edit.
-//
-// 0.5 matches `difflib.SequenceMatcher.ratio()`-style heuristics used
-// by VS Code, IntelliJ and most diff viewers.
-const SIMILARITY_THRESHOLD = 0.5;
+// Tunable at runtime via `editor.getPluginApi("live-diff").setSimilarityThreshold(x)`.
+let similarityThreshold = 0.95;
 // Bail out of char-LCS on huge lines; cost is O(m * n).
 const MAX_LINE_LCS_CHARS = 2000;
 // Bail out of word-LCS when either side has more tokens than this;
@@ -127,6 +130,12 @@ interface Hunk {
    * underline the actually-changed words on the new line. `undefined`
    * for unrefined hunks and for `added`/`removed` hunks. */
   wordRanges?: WordRange[][];
+  /** Old-side word ranges, one entry per `oldLines` line. Set on
+   * `removed` hunks emitted by `refineHunks` for high-similarity
+   * pairs where words were dropped/changed; passed to addVirtualLine
+   * as `textOverlays` so the deletion virtual line bolds + underlines
+   * the actually-removed words. */
+  oldWordRanges?: WordRange[][];
 }
 
 interface BufferDiffState {
@@ -559,29 +568,58 @@ function tokenize(s: string): Token[] {
   return tokens;
 }
 
+/** Word-level diff result: byte ranges on each side that aren't part
+ * of the longest common token subsequence. `newRanges` drives the
+ * bold + underline overlay on the new (modified) line; `oldRanges`
+ * drives the same overlay on the deletion virtual line so removed
+ * words are visually called out, not just present in the gutter. */
+interface WordDiff {
+  newRanges: WordRange[];
+  oldRanges: WordRange[];
+}
+
 /**
- * Compute the byte ranges of words on the new-side line that are not
- * part of the longest common token subsequence with the old-side
- * line. Whitespace-only tokens are never highlighted (whitespace
- * changes mid-word look like noise; whole-line whitespace edits are
- * handled by the line-level diff). Adjacent unmatched non-whitespace
- * tokens are coalesced into a single range so a renamed
- * `foo.bar.baz` becomes one underline, not three.
+ * Token-level LCS over the two lines. Returns the byte ranges of
+ * non-whitespace tokens on each side that aren't part of the LCS.
+ * Whitespace-only tokens are never highlighted (whitespace changes
+ * mid-word look like noise; whole-line whitespace edits are handled
+ * by the line-level diff). Adjacent unmatched non-whitespace tokens
+ * are coalesced into a single range so a renamed `foo.bar.baz`
+ * becomes one underline, not three.
  */
-function computeWordDiff(oldS: string, newS: string): WordRange[] {
+function computeWordDiff(oldS: string, newS: string): WordDiff {
   const oldTokens = tokenize(oldS);
   const newTokens = tokenize(newS);
   const m = oldTokens.length;
   const n = newTokens.length;
-  if (n === 0) return [];
-  if (m === 0 || m > MAX_WORD_TOKENS || n > MAX_WORD_TOKENS) {
-    // Either nothing to compare against or the line is so long that
-    // the token DP would dwarf the line-level pass. Mark every non-
-    // whitespace token as changed so the user still sees *something*.
-    return collapseRanges(
-      newTokens
-        .filter((t) => !WHITESPACE_CHAR.test(t.text[0] ?? "")),
-    );
+  if (m === 0 && n === 0) return { newRanges: [], oldRanges: [] };
+  if (m > MAX_WORD_TOKENS || n > MAX_WORD_TOKENS) {
+    // Token DP would dwarf the line-level pass; degrade to "every
+    // non-whitespace token changed" on whichever side has tokens.
+    return {
+      newRanges: collapseRanges(
+        newTokens.filter((t) => !WHITESPACE_CHAR.test(t.text[0] ?? "")),
+      ),
+      oldRanges: collapseRanges(
+        oldTokens.filter((t) => !WHITESPACE_CHAR.test(t.text[0] ?? "")),
+      ),
+    };
+  }
+  if (m === 0) {
+    return {
+      newRanges: collapseRanges(
+        newTokens.filter((t) => !WHITESPACE_CHAR.test(t.text[0] ?? "")),
+      ),
+      oldRanges: [],
+    };
+  }
+  if (n === 0) {
+    return {
+      newRanges: [],
+      oldRanges: collapseRanges(
+        oldTokens.filter((t) => !WHITESPACE_CHAR.test(t.text[0] ?? "")),
+      ),
+    };
   }
   const stride = n + 1;
   const dp: number[] = new Array((m + 1) * stride).fill(0);
@@ -597,13 +635,15 @@ function computeWordDiff(oldS: string, newS: string): WordRange[] {
       }
     }
   }
-  // Backtrack to find which newTokens are in the LCS pairing.
-  const matched: boolean[] = new Array(n).fill(false);
+  // Backtrack to find which old/new tokens participate in the LCS.
+  const matchedOld: boolean[] = new Array(m).fill(false);
+  const matchedNew: boolean[] = new Array(n).fill(false);
   let i = m;
   let j = n;
   while (i > 0 && j > 0) {
     if (oldTokens[i - 1].text === newTokens[j - 1].text) {
-      matched[j - 1] = true;
+      matchedOld[i - 1] = true;
+      matchedNew[j - 1] = true;
       i--;
       j--;
     } else if (dp[(i - 1) * stride + j] >= dp[i * stride + (j - 1)]) {
@@ -612,14 +652,23 @@ function computeWordDiff(oldS: string, newS: string): WordRange[] {
       j--;
     }
   }
-  const unmatched: Token[] = [];
-  for (let k = 0; k < n; k++) {
-    if (matched[k]) continue;
-    const t = newTokens[k];
-    if (WHITESPACE_CHAR.test(t.text[0] ?? "")) continue;
-    unmatched.push(t);
-  }
-  return collapseRanges(unmatched);
+  const unmatchedOf = (
+    tokens: Token[],
+    matched: boolean[],
+  ): WordRange[] => {
+    const out: Token[] = [];
+    for (let k = 0; k < tokens.length; k++) {
+      if (matched[k]) continue;
+      const t = tokens[k];
+      if (WHITESPACE_CHAR.test(t.text[0] ?? "")) continue;
+      out.push(t);
+    }
+    return collapseRanges(out);
+  };
+  return {
+    newRanges: unmatchedOf(newTokens, matchedNew),
+    oldRanges: unmatchedOf(oldTokens, matchedOld),
+  };
 }
 
 /** Merge adjacent or touching token ranges into a single range so
@@ -641,9 +690,12 @@ function collapseRanges(tokens: Token[]): WordRange[] {
  * Post-process `opsToHunks` output: split low-similarity 1:1
  * `modified` hunks into separate `removed` (virtual deletion line) +
  * `added` (bg-highlighted) hunks. High-similarity pairs stay as
- * `modified` but drop their old lines (so no virtual line renders)
- * and gain a `wordRanges` entry that drives the bold + underline
- * word-level overlay.
+ * `modified` and gain a `wordRanges` entry that drives the bold +
+ * underline word-level overlay on the new line. When a high-similarity
+ * pair also has *removed* (or otherwise unmatched) old-side words,
+ * we additionally emit a `removed` hunk carrying the old line plus
+ * `oldWordRanges` so the deletion virtual line shows the user which
+ * words went away — not just that *something* did.
  *
  * Hunks that don't have a 1:1 mapping (e.g. 3 old lines becoming 2
  * new lines) keep their original shape — the pairing is ambiguous,
@@ -661,14 +713,28 @@ function refineHunks(hunks: Hunk[], newLines: string[]): Hunk[] {
       const oldLine = h.oldLines[i];
       const newLine = newLines[h.newStart + i] ?? "";
       const sim = lineSimilarity(oldLine, newLine);
-      if (sim >= SIMILARITY_THRESHOLD) {
-        const ranges = computeWordDiff(oldLine, newLine);
+      if (sim >= similarityThreshold) {
+        const wd = computeWordDiff(oldLine, newLine);
+        // Always emit the in-place modified hunk (drives the new-line
+        // bg highlight + new-side word-diff). When old-side has
+        // unmatched non-WS tokens, also emit a deletion line above
+        // it carrying old-side word ranges so the user can see which
+        // words were removed/replaced.
+        if (wd.oldRanges.length > 0) {
+          out.push({
+            kind: "removed",
+            newStart: h.newStart + i,
+            newCount: 0,
+            oldLines: [oldLine],
+            oldWordRanges: [wd.oldRanges],
+          });
+        }
         out.push({
           kind: "modified",
           newStart: h.newStart + i,
           newCount: 1,
           oldLines: [],
-          wordRanges: [ranges],
+          wordRanges: [wd.newRanges],
         });
       } else {
         out.push({
@@ -860,6 +926,18 @@ function renderHunks(state: BufferDiffState, newLines: string[]): void {
       // No "- " prefix in the line text — the indicator goes in the
       // gutter via `gutterGlyph` so it sits next to the deletion
       // line itself, not on the source line that follows it.
+      // When `oldWordRanges` is set (from a high-similarity refined
+      // pair), bold + underline the actually-removed words so the
+      // user can see *what* changed, not just that something did.
+      const wordRanges = h.oldWordRanges?.[i];
+      const textOverlays = wordRanges
+        ? wordRanges.map((r) => ({
+            start: r.start,
+            end: r.end,
+            bold: true,
+            underline: true,
+          }))
+        : [];
       editor.addVirtualLine(
         bid,
         anchor,
@@ -869,6 +947,7 @@ function renderHunks(state: BufferDiffState, newLines: string[]): void {
           bg: THEME.removedBg,
           gutterGlyph: SYMBOLS.removed,
           gutterColor: GUTTER_COLORS.removed,
+          textOverlays,
         },
         above,
         NS_VLINE,
@@ -1226,6 +1305,42 @@ editor.registerCommand("%cmd.vs_default_branch", "%cmd.vs_default_branch_desc",
 editor.registerCommand("%cmd.refresh", "%cmd.refresh_desc", "live_diff_refresh", null);
 editor.registerCommand("%cmd.set_default", "%cmd.set_default_desc", "live_diff_set_default", null);
 
+// =============================================================================
+// Plugin API
+// =============================================================================
+
+export type LiveDiffApi = {
+  /** Lines whose Sørensen–Dice similarity ratio is at least this value
+   * render as in-place "modified" (bg highlight + word-level diff on the
+   * new line). Below this they split into a removed + added pair so the
+   * change reads as a rewrite. Range 0..1; clamped. */
+  setSimilarityThreshold(value: number): void;
+  getSimilarityThreshold(): number;
+};
+
+declare global {
+  interface FreshPluginRegistry {
+    "live-diff": LiveDiffApi;
+  }
+}
+
+editor.exportPluginApi("live-diff", {
+  setSimilarityThreshold(value: number): void {
+    const clamped = Math.max(0, Math.min(1, value));
+    if (clamped === similarityThreshold) return;
+    similarityThreshold = clamped;
+    // Invalidate cached hunks so the next recompute repaints with the
+    // new threshold instead of short-circuiting on the same hunksKey.
+    for (const state of states.values()) {
+      state.lastHunksKey = "";
+      scheduleRecompute(state.bufferId).catch((e) =>
+        editor.error(`live-diff: ${e}`),
+      );
+    }
+  },
+  getSimilarityThreshold: () => similarityThreshold,
+} satisfies LiveDiffApi);
+
 // =============================================================================
 // Initialization
 // =============================================================================

package/plugins/merge_conflict.ts

@@ -100,33 +100,90 @@ const mergeState: MergeState = {
   resultContent: "",
 };
 
+// Caches for the buffer_activated / after_file_open detection path.
+// Without these, every tab switch re-spawns `git rev-parse` + `git ls-files`
+// even though their answers rarely change. The detection path is purely a
+// status-bar hint, so a stale answer for a few seconds is harmless.
+const inGitRepoCache: Map<string, boolean> = new Map();
+const detectionLastCheck: Map<string, number> = new Map();
+const DETECTION_TTL_MS = 30_000;
+const detectionInFlight: Map<string, Promise<void>> = new Map();
+
+async function isInGitRepo(fileDir: string): Promise<boolean> {
+  const cached = inGitRepoCache.get(fileDir);
+  if (cached !== undefined) return cached;
+  const gitCheck = await editor.spawnProcess(
+    "git",
+    ["rev-parse", "--is-inside-work-tree"],
+    fileDir,
+  );
+  const ok = gitCheck.exit_code === 0;
+  inGitRepoCache.set(fileDir, ok);
+  return ok;
+}
+
+async function detectMergeConflictFor(
+  path: string,
+  statusOnDetect: () => string,
+): Promise<void> {
+  if (mergeState.isActive) return;
+  if (!path) return;
+
+  const last = detectionLastCheck.get(path);
+  if (last !== undefined && Date.now() - last < DETECTION_TTL_MS) return;
+
+  // Coalesce concurrent callers for the same path onto one in-flight check
+  // (e.g. buffer_activated + after_file_open firing back-to-back).
+  const existing = detectionInFlight.get(path);
+  if (existing) return existing;
+
+  const fileDir = editor.pathDirname(path);
+  const promise = (async () => {
+    try {
+      if (!(await isInGitRepo(fileDir))) return;
+      const lsFiles = await editor.spawnProcess(
+        "git",
+        ["ls-files", "-u", path],
+        fileDir,
+      );
+      if (lsFiles.exit_code === 0 && lsFiles.stdout.trim().length > 0) {
+        editor.setStatus(statusOnDetect());
+      }
+      detectionLastCheck.set(path, Date.now());
+    } catch (_e) {
+      // Not in git repo or other error, ignore
+    } finally {
+      detectionInFlight.delete(path);
+    }
+  })();
+  detectionInFlight.set(path, promise);
+  return promise;
+}
+
 // =============================================================================
 // Color Definitions
 // =============================================================================
 
+// Theme keys preferred over hard-coded RGB so the look tracks the
+// active theme. `addOverlay` accepts theme key strings directly.
+const OURS_FG_KEY = "editor.diff_add_bg";        // green-ish in most themes
+const THEIRS_FG_KEY = "editor.diff_remove_bg";   // red-ish
+const UNRESOLVED_FG_KEY = "ui.file_status_conflicted_fg";
+
 const colors = {
-  // Panel headers
-  oursHeader: [100, 200, 255] as [number, number, number],    // Cyan for OURS
-  theirsHeader: [255, 180, 100] as [number, number, number],  // Orange for THEIRS
-  resultHeader: [150, 255, 150] as [number, number, number],  // Green for RESULT
-
-  // Conflict highlighting
-  conflictOurs: [50, 80, 100] as [number, number, number],    // Blue-tinted background
-  conflictTheirs: [100, 70, 50] as [number, number, number],  // Orange-tinted background
-  conflictBase: [70, 70, 70] as [number, number, number],     // Gray for base
-
-  // Intra-line diff colors
-  diffAdd: [50, 100, 50] as [number, number, number],         // Green for additions
-  diffDel: [100, 50, 50] as [number, number, number],         // Red for deletions
-  diffMod: [50, 50, 100] as [number, number, number],         // Blue for modifications
-
-  // Selection
-  selected: [80, 80, 120] as [number, number, number],        // Selection highlight
-
-  // Buttons/actions
-  button: [100, 149, 237] as [number, number, number],        // Cornflower blue
-  resolved: [100, 200, 100] as [number, number, number],      // Green for resolved
-  unresolved: [200, 100, 100] as [number, number, number],    // Red for unresolved
+  // RGB tuples retained for any future contributor who reaches for them
+  // — the active call sites use the theme keys above. None of these
+  // appear in the currently rendered UI.
+  oursHeader: [100, 200, 255] as [number, number, number],
+  theirsHeader: [255, 180, 100] as [number, number, number],
+  resultHeader: [150, 255, 150] as [number, number, number],
+  conflictBase: [70, 70, 70] as [number, number, number],
+  diffAdd: [50, 100, 50] as [number, number, number],
+  diffDel: [100, 50, 50] as [number, number, number],
+  diffMod: [50, 50, 100] as [number, number, number],
+  selected: [80, 80, 120] as [number, number, number],
+  button: [100, 149, 237] as [number, number, number],
+  resolved: [100, 200, 100] as [number, number, number],
 };
 
 // =============================================================================
@@ -950,7 +1007,7 @@ function highlightPanel(bufferId: number, side: "ours" | "theirs"): void {
   const lines = content.split("\n");
 
   let byteOffset = 0;
-  const conflictColor = side === "ours" ? colors.conflictOurs : colors.conflictTheirs;
+  const conflictColor = side === "ours" ? OURS_FG_KEY : THEIRS_FG_KEY;
 
   for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
     const line = lines[lineIdx];
@@ -989,7 +1046,7 @@ function highlightResultPanel(bufferId: number): void {
     // Highlight conflict markers
     if (line.startsWith("<<<<<<<") || line.startsWith("=======") || line.startsWith(">>>>>>>")) {
       editor.addOverlay(bufferId, `merge-marker-${lineIdx}`, lineStart, lineEnd, {
-        fg: colors.unresolved,
+        fg: UNRESOLVED_FG_KEY,
         underline: true,
       });
     }
@@ -1712,50 +1769,18 @@ registerHandler("merge_show_help", merge_show_help);
 // =============================================================================
 
 editor.on("buffer_activated", async (data) => {
-  // Don't trigger if already in merge mode
-  if (mergeState.isActive) return;
-
-  // Don't trigger for virtual buffers
   const info = editor.getBufferInfo(data.buffer_id);
   if (!info || !info.path) return;
-
-  // Get the directory of the file for running git commands
-  const fileDir = editor.pathDirname(info.path);
-
-  // Check if we're in a git repo first
-  try {
-    const gitCheck = await editor.spawnProcess("git", ["rev-parse", "--is-inside-work-tree"], fileDir);
-    if (gitCheck.exit_code !== 0) return;
-
-    // Check for unmerged entries
-    const lsFiles = await editor.spawnProcess("git", ["ls-files", "-u", info.path], fileDir);
-    if (lsFiles.exit_code === 0 && lsFiles.stdout.trim().length > 0) {
-      editor.setStatus(editor.t("status.detected"));
-    }
-  } catch (e) {
-    // Not in git repo or other error, ignore
-  }
+  await detectMergeConflictFor(info.path, () => editor.t("status.detected"));
 });
 editor.on("after_file_open", async (data) => {
-  // Don't trigger if already in merge mode
-  if (mergeState.isActive) return;
-
-  // Get the directory of the file for running git commands
-  const fileDir = editor.pathDirname(data.path);
-
-  // Check if we're in a git repo first
-  try {
-    const gitCheck = await editor.spawnProcess("git", ["rev-parse", "--is-inside-work-tree"], fileDir);
-    if (gitCheck.exit_code !== 0) return;
-
-    // Check for unmerged entries
-    const lsFiles = await editor.spawnProcess("git", ["ls-files", "-u", data.path], fileDir);
-    if (lsFiles.exit_code === 0 && lsFiles.stdout.trim().length > 0) {
-      editor.setStatus(editor.t("status.detected_file", { path: data.path }));
-    }
-  } catch (e) {
-    // Not in git repo or other error, ignore
-  }
+  // File-open is a strong signal that state may have changed externally
+  // (e.g. user ran `git merge` then opened the conflicted file). Bypass the
+  // per-path TTL so the detection still runs.
+  detectionLastCheck.delete(data.path);
+  await detectMergeConflictFor(data.path, () =>
+    editor.t("status.detected_file", { path: data.path }),
+  );
 });
 
 // =============================================================================