@fresh-editor/fresh-editor 0.3.7 → 0.3.9

package/plugins/git_log.ts

@@ -5,7 +5,7 @@ import {
   buildCommitLogEntries,
   fetchGitLog,
 } from "./lib/git_history.ts";
-import { button, flexSpacer, key, list, row, WidgetPanel } from "./lib/index.ts";
+import { button, flexSpacer, list, row, WidgetPanel } from "./lib/index.ts";
 
 const editor = getEditor();
 
@@ -105,20 +105,23 @@ const SELECT_DEBOUNCE_MS = 60;
 // the log, and opens the file at the cursor when pressed in the detail).
 // =============================================================================
 
-// j/k/Up/Down/PageUp/PageDown route to the log List widget so the host
-// owns selection + scroll + auto-scroll. The List's `select` event then
-// fires back into the plugin's `widget_event` handler for detail-pane
-// refresh. Other plugin actions (q/r/y/Tab/Return) stay as direct
-// bindings — they don't depend on which row is highlighted.
+// The log pane is cursor-driven: j/k/Up/Down/PageUp/PageDown move the
+// pane's real buffer cursor (normal editor movement), which scrolls via
+// the standard `ensure_cursor_visible` wheel — only when the cursor
+// crosses the top/bottom edge. The cursor is the source of truth for
+// which commit is selected; a `cursor_moved` subscription mirrors its
+// line into the List highlight + detail pane. On the detail pane the
+// same keys scroll the diff. Other actions (q/r/y/Tab/Return) are direct
+// bindings — they don't depend on the cursor row.
 editor.defineMode(
   "git-log",
   [
-    ["k", "git_log_select_up"],
-    ["j", "git_log_select_down"],
-    ["Up", "git_log_select_up"],
-    ["Down", "git_log_select_down"],
-    ["PageUp", "git_log_select_page_up"],
-    ["PageDown", "git_log_select_page_down"],
+    ["k", "move_up"],
+    ["j", "move_down"],
+    ["Up", "move_up"],
+    ["Down", "move_down"],
+    ["PageUp", "move_page_up"],
+    ["PageDown", "move_page_down"],
     ["Return", "git_log_enter"],
     ["Tab", "git_log_tab"],
     ["q", "git_log_q"],
@@ -130,52 +133,6 @@ editor.defineMode(
   true, // inherit Normal-context bindings for unbound keys
 );
 
-function git_log_select_up(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("Up"));
-  } else {
-    editor.executeAction("move_up");
-  }
-}
-function git_log_select_down(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("Down"));
-  } else {
-    editor.executeAction("move_down");
-  }
-}
-function git_log_select_page_up(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("PageUp"));
-  } else {
-    editor.executeAction("move_page_up");
-  }
-}
-function git_log_select_page_down(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("PageDown"));
-  } else {
-    editor.executeAction("move_page_down");
-  }
-}
-
-/** True iff the log panel is the focused buffer in the group. The
- * group's bindings (j/k/Up/Down/PageUp/PageDown) apply to all panels
- * uniformly; we only want navigation to drive the List widget when
- * the user is *on* the log panel. From the detail panel, the same
- * keys must move the buffer cursor (so users can scroll the diff
- * before pressing Enter on a diff line to open the file view). */
-function isLogPanelActive(): boolean {
-  return (
-    state.logBufferId !== null &&
-    editor.getActiveBufferId() === state.logBufferId
-  );
-}
-registerHandler("git_log_select_up", git_log_select_up);
-registerHandler("git_log_select_down", git_log_select_down);
-registerHandler("git_log_select_page_up", git_log_select_page_up);
-registerHandler("git_log_select_page_down", git_log_select_page_down);
-
 // =============================================================================
 // Panel layout
 // =============================================================================
@@ -268,19 +225,13 @@ editor.on("widget_event", (data) => {
     }
     return;
   }
-  // Log pane (List of commit rows) — `select` fires on j/k/Up/Down/
-  // PageUp/PageDown navigation and on row clicks; `activate` fires on
-  // Enter or double-click.
+  // Log pane (List of commit rows). Selection is cursor-driven (see the
+  // `cursor_moved` handler), so the List's `select` event is ignored —
+  // a row click places the buffer cursor, and `cursor_moved` mirrors it
+  // into the selection. `activate` (Enter / double-click) still opens.
   if (state.logPanel !== null && data.panel_id === state.logPanel.id()) {
-    if (data.event_type === "select") {
-      const idx =
-        typeof data.payload?.index === "number" ? data.payload.index : -1;
-      if (idx >= 0) void on_log_select(idx);
-      return;
-    }
     if (data.event_type === "activate") {
       void git_log_enter();
-      return;
     }
     return;
   }
@@ -300,6 +251,11 @@ function detailFooter(hash: string): string {
   return editor.t("status.commit_ready", { hash });
 }
 
+/** Stable widget key for the log List. The host keys selection +
+ * scroll instance state off this; the plugin re-pins selection
+ * through it after click/keyboard `select` events. */
+const LOG_LIST_KEY = "git-log-list";
+
 function renderLog(): void {
   if (state.logPanel === null) return;
   // List takes the per-row entries directly. selectedIndex: -1 on the
@@ -321,7 +277,7 @@ function renderLog(): void {
       // scroll handle viewport. Revisit if commit lists grow into the
       // tens of thousands.
       visibleRows: Math.max(1, state.commits.length),
-      key: "git-log-list",
+      key: LOG_LIST_KEY,
     }),
   );
 }
@@ -652,13 +608,20 @@ async function show_git_log(): Promise<void> {
 
   renderToolbar();
   renderLog();
-  // List widget's instance state is the source of truth for selection;
-  // no buffer-cursor positioning needed (the renderer auto-scrolls so
-  // the selected row stays visible).
+  // Cursor-driven selection: give the log pane a real, visible cursor and
+  // take ownership of it (`setBufferShowCursors` locks it so the widget
+  // runtime won't clear it on repaint). The cursor's line is the selected
+  // commit; `cursor_moved` mirrors it into the List highlight + detail.
+  // Start on HEAD (line 0). Scrolling is the normal cursor-follow wheel.
+  if (state.logBufferId !== null) {
+    editor.setBufferShowCursors(state.logBufferId, true);
+    editor.setBufferCursor(state.logBufferId, 0);
+  }
   await refreshDetail();
 
   editor.on("resize", on_git_log_resize);
   editor.on("buffer_closed", on_git_log_buffer_closed);
+  editor.on("cursor_moved", on_git_log_cursor_moved);
 
   editor.setStatus(
     editor.t("status.log_ready", { count: String(state.commits.length) })
@@ -673,6 +636,7 @@ function git_log_cleanup(): void {
   if (!state.isOpen) return;
   editor.off("resize", on_git_log_resize);
   editor.off("buffer_closed", on_git_log_buffer_closed);
+  editor.off("cursor_moved", on_git_log_cursor_moved);
   // Kill any still-running `git show` spawns — we no longer care.
   for (const [, handle] of state.inFlightSpawns) {
     handle.kill?.();
@@ -1114,15 +1078,34 @@ function git_log_file_view_close(): void {
 registerHandler("git_log_file_view_close", git_log_file_view_close);
 
 // =============================================================================
-// Selection tracking — live-update the detail panel as the user
-// navigates the List. Driven by `widget_event "select"` from the host.
+// Selection tracking — the log pane is cursor-driven. The buffer cursor's
+// line (set by arrow-key movement or a click) is the selected commit; this
+// `cursor_moved` subscription mirrors it into the List highlight and the
+// detail pane. Scrolling is handled by the normal cursor-follow wheel, so
+// the viewport only moves when the cursor crosses the top/bottom edge.
 // =============================================================================
 
-async function on_log_select(idx: number): Promise<void> {
+function on_git_log_cursor_moved(data: { buffer_id: number; line: number }): void {
+  if (!state.isOpen || state.logBufferId === null) return;
+  if (data.buffer_id !== state.logBufferId) return;
+  // `cursor_moved.line` is 1-based; commit rows are 0-based (no header),
+  // so the selected commit index is `line - 1`.
+  const idx = data.line - 1;
+  if (idx < 0 || idx >= state.commits.length) return;
+  void selectCommitLine(idx);
+}
+
+async function selectCommitLine(idx: number): Promise<void> {
   if (!state.isOpen) return;
   if (idx === state.selectedIndex) return;
   state.selectedIndex = idx;
 
+  // Move the List's highlight bar to the cursor's row. The cursor itself
+  // is the real (plugin-owned) buffer cursor, so it stays exactly where
+  // the user moved or clicked it — this only repaints the row styling,
+  // and the repaint preserves the cursor position.
+  state.logPanel?.setSelectedIndex(LOG_LIST_KEY, idx);
+
   const commit = state.commits[state.selectedIndex];
   if (commit) {
     editor.setStatus(

package/plugins/lib/finder.ts

@@ -447,6 +447,33 @@ export class Finder<T> {
   // Mode flags
   private isPromptMode = false;
   private isPanelMode = false;
+  /** True when the active prompt is a centred floating overlay. Search
+   *  status then goes to the overlay's own footer (visible inside the frame)
+   *  rather than the editor status bar (off at the bottom, easy to miss). */
+  private isOverlay = false;
+
+  /** Present a search-status message where the user is actually looking: on
+   *  the overlay's input row (right-aligned by the match count) for a
+   *  floating overlay, else the editor status bar. */
+  private setSearchStatus(message: string): void {
+    if (this.isOverlay) {
+      this.editor.setPromptStatus(message);
+    } else {
+      this.editor.setStatus(message);
+    }
+  }
+
+  /** Report a successful search with `count` matches. In overlay mode the
+   *  "N / total" count on the input row already conveys this, so the status
+   *  is cleared to avoid duplicating it; the status bar (non-overlay) still
+   *  shows "Found N matches". */
+  private reportFound(count: number): void {
+    if (this.isOverlay) {
+      this.editor.setPromptStatus("");
+    } else {
+      this.editor.setStatus(`Found ${count} matches`);
+    }
+  }
 
   // Handler names (for cleanup)
   private handlerPrefix: string;
@@ -513,6 +540,7 @@ export class Finder<T> {
 
     // Start the prompt
     const overlay = options.floatingOverlay === true;
+    this.isOverlay = overlay;
     if (options.initialQuery) {
       this.editor.startPromptWithInitial(
         options.title,
@@ -525,7 +553,7 @@ export class Finder<T> {
       const result = this.editor.startPrompt(options.title, this.config.id, overlay);
       this.editor.debug(`[Finder] startPrompt returned: ${result}`);
     }
-    this.editor.setStatus("Type to search...");
+    this.setSearchStatus("Type to search…");
   }
 
   /**
@@ -545,6 +573,11 @@ export class Finder<T> {
     // unchanged query.
     this.promptState.lastQuery = "";
     if (query.length === 0) return;
+    // The backend (or scope set) changed, so the on-screen results are now
+    // stale. Clear them and show progress immediately rather than leaving the
+    // previous output up while the (possibly slow) new search runs.
+    this.updatePromptResults([]);
+    this.setSearchStatus("Searching…");
     await this.runSearch(query, this.currentSource);
   }
 
@@ -713,9 +746,9 @@ export class Finder<T> {
       this.updatePromptResults(filtered);
 
       if (filtered.length > 0) {
-        this.editor.setStatus(`Found ${filtered.length} matches`);
+        this.reportFound(filtered.length);
       } else {
-        this.editor.setStatus("No matches");
+        this.setSearchStatus("No matches");
       }
     } else {
       // Search mode: run external search
@@ -745,6 +778,7 @@ export class Finder<T> {
       }
       this.editor.setPromptSuggestions([]);
       this.promptState.results = [];
+      this.setSearchStatus("");
       return;
     }
 
@@ -768,6 +802,11 @@ export class Finder<T> {
     }
     this.promptState.lastQuery = query;
 
+    // A search is now actually starting (every query change that gets here —
+    // typing, deleting, provider/scope refresh). Show pending status so the
+    // user sees the re-scan in progress rather than a stale result count.
+    this.setSearchStatus("Searching…");
+
     try {
       const searchResult = source.search(query);
 
@@ -793,21 +832,21 @@ export class Finder<T> {
           this.updatePromptResults(parsed);
 
           if (parsed.length > 0) {
-            this.editor.setStatus(`Found ${parsed.length} matches`);
+            this.reportFound(parsed.length);
             // Show preview of first result
             if (this.shouldShowPreview()) {
               await this.updatePreview(this.promptState.entries[0]);
             }
           } else {
-            this.editor.setStatus("No matches");
+            this.setSearchStatus("No matches");
           }
         } else if (result.exit_code === 1) {
           // No matches
           this.updatePromptResults([]);
-          this.editor.setStatus("No matches");
+          this.setSearchStatus("No matches");
         } else if (result.exit_code !== -1) {
           // Error (ignore -1 which means killed)
-          this.editor.setStatus(`Search error: ${result.stderr}`);
+          this.setSearchStatus(`Search error: ${result.stderr}`);
         }
       } else {
         // Promise<T[]>
@@ -821,12 +860,12 @@ export class Finder<T> {
         this.updatePromptResults(results);
 
         if (results.length > 0) {
-          this.editor.setStatus(`Found ${results.length} matches`);
+          this.reportFound(results.length);
           if (this.shouldShowPreview()) {
             await this.updatePreview(this.promptState.entries[0]);
           }
         } else {
-          this.editor.setStatus("No matches");
+          this.setSearchStatus("No matches");
         }
       }
     } catch (e) {
@@ -864,7 +903,15 @@ export class Finder<T> {
       (entry, i) => ({
         text: entry.label,
         description: entry.description,
-        value: `${i}`,
+        // The preview pane uses `value` as the authoritative
+        // `path:line:col` for the result. We must not rely on parsing the
+        // user-facing label, which may carry source badges (e.g. "[term]")
+        // that make the label unparseable as a path.
+        value: entry.location
+          ? `${entry.location.file}:${entry.location.line}:${
+            entry.location.column ?? 1
+          }`
+          : `${i}`,
         disabled: false,
       })
     );

package/plugins/lib/fresh.d.ts

@@ -621,6 +621,50 @@ type TerminalResult = {
 	*/
 	splitId: number | null;
 };
+type CreateWindowWithTerminalOptions = {
+	/**
+	* Absolute path to the new session's worktree / project
+	* root. Relative paths are rejected (logged, no window
+	* created).
+	*/
+	root: string;
+	/**
+	* Human-readable label for the new session. When empty,
+	* defaults to the basename of `root`.
+	*/
+	label: string;
+	/**
+	* Working directory for the spawned terminal. Defaults to
+	* `root` when omitted.
+	*/
+	cwd?: string;
+	/**
+	* Argv to spawn directly inside the PTY. `None` keeps the
+	* shell-and-type behaviour; `Some([cmd, ...args])` runs the
+	* command as the PTY child (used by Orchestrator so the
+	* agent process is the PTY's direct child).
+	*/
+	command?: Array<string>;
+	/**
+	* Tab title override. Defaults to `command[0]`'s basename
+	* when `command` is set, or "Terminal N" otherwise.
+	*/
+	title?: string;
+};
+type SessionWithTerminalResult = {
+	/**
+	* The new window's id.
+	*/
+	windowId: number;
+	/**
+	* The seeded terminal's id (for `sendTerminalInput`, etc.).
+	*/
+	terminalId: number;
+	/**
+	* The seeded terminal buffer's id.
+	*/
+	bufferId: number;
+};
 type CreateTerminalOptions = {
 	/**
 	* Working directory for the terminal (defaults to editor cwd)
@@ -691,6 +735,13 @@ type CursorInfo = {
 		start: number;
 		end: number;
 	} | null;
+	/**
+	* 0-indexed line number of the cursor. `None` when the line index is
+	* unavailable — e.g. a huge file whose line scan hasn't completed, where
+	* the editor positions purely by byte offset. Plugins must treat `null`
+	* as "unknown", never as line 0.
+	*/
+	line: number | null;
 };
 type OverlayOptions = {
 	/**
@@ -722,6 +773,13 @@ type OverlayOptions = {
 	*/
 	extendToLineEnd: boolean;
 	/**
+	* When `true`, `fg` is applied only on cells whose existing fg
+	* matches this overlay's resolved bg — i.e. a same-colour fg/bg
+	* collision. Lets a row-wide overlay stay legible on tokens that
+	* share the bg's colour without repainting unrelated tokens.
+	*/
+	fgOnCollisionOnly: boolean;
+	/**
 	* Optional URL for OSC 8 terminal hyperlinks.
 	* When set, the overlay text becomes a clickable hyperlink in terminals
 	* that support OSC 8 escape sequences.
@@ -1006,7 +1064,7 @@ type WidgetSpec = {
 	* `WidgetMutation::SetCompletions`. An empty `items`
 	* closes the popup.
 	*/
-	completions?: Array<string>;
+	completions?: Array<string | CompletionItem>;
 	/**
 	* How many candidate rows the popup paints at once
 	* when it opens. Excess candidates stay reachable
@@ -1091,7 +1149,7 @@ type WidgetMutation = {
 } | {
 	"kind": "setCompletions";
 	widgetKey: string;
-	items: Array<string>;
+	items: Array<string | CompletionItem>;
 } | {
 	"kind": "setChecked";
 	widgetKey: string;
@@ -1644,7 +1702,13 @@ interface EditorAPI {
 	*/
 	listSplits(): SplitSnapshot[];
 	/**
-	* Get the line number (0-indexed) of the primary cursor
+	* Get the line number (0-indexed) of the primary cursor.
+	* 
+	* @deprecated Use `getPrimaryCursor()?.line` instead. This accessor cannot
+	* represent "line index unavailable" (huge files before their line scan) —
+	* it returns `0` in that case, indistinguishable from a real first line.
+	* `getPrimaryCursor().line` is `number | null` and also covers every cursor
+	* via `getAllCursors()`.
 	*/
 	getCursorLine(): number;
 	/**
@@ -1813,6 +1877,20 @@ interface EditorAPI {
 	*/
 	getAuthorityLabel(): string;
 	/**
+	* Current Workspace Trust level for the active project: `"restricted"`,
+	* `"trusted"`, or `"blocked"` (empty when unavailable). Exposed to JS as
+	* `editor.workspaceTrustLevel()`. Plugins that run repo-controlled work
+	* should treat anything other than `"trusted"` as "do not execute".
+	*/
+	workspaceTrustLevel(): string;
+	/**
+	* Whether an environment is currently active (set via `editor.setEnv`).
+	* Exposed to JS as `editor.envActive()`. Lets the env-manager plugin
+	* reflect activation and re-establish its file watch after the restart
+	* that `setEnv` triggers.
+	*/
+	envActive(): boolean;
+	/**
 	* Join path components (variadic - accepts multiple string arguments)
 	* Always uses forward slashes for cross-platform consistency (like Node.js path.posix.join)
 	* 
@@ -2048,6 +2126,21 @@ interface EditorAPI {
 	*/
 	getDataDir(): string;
 	/**
+	* Per-working-directory data root for plugin state that should be scoped
+	* to the current project root / worktree rather than shared across all of
+	* them (`<data_dir>/workdirs/<encoded-cwd>/`). Prefer this over
+	* `getDataDir()` for per-project state; the directory is not created for
+	* you. Note: terminal scrollback and orchestrator state use their own
+	* dedicated layouts (see `getTerminalDir()`), not this root.
+	*/
+	getWorkingDataDir(): string;
+	/**
+	* Directory holding terminal scrollback backing files for the current
+	* working directory. Each project root / worktree has its own subdir, so
+	* a search can stay scoped to the active project's terminals.
+	*/
+	getTerminalDir(): string;
+	/**
 	* Get themes directory path
 	*/
 	getThemesDir(): string;
@@ -2386,6 +2479,29 @@ interface EditorAPI {
 	*/
 	setPromptFooter(footer: StyledText[]): boolean;
 	/**
+	* Set the floating-overlay prompt's header toolbar as a `WidgetSpec`
+	* (real, clickable `Toggle`/`Button` widgets), rendered in place of the
+	* styled-text title. Give each control a `key` equal to the action it
+	* should fire on click (e.g. `"live_grep_toggle_files"`). Pass `null` to
+	* clear it. No visible effect on non-overlay prompts.
+	*/
+	setPromptToolbar(spec: WidgetSpec | null): boolean;
+	/**
+	* Set the floating-overlay prompt's input-row status text, shown
+	* right-aligned just left of the `selected / total` count (e.g.
+	* "Searching…", "No matches"). Empty string clears it. No effect on
+	* non-overlay prompts.
+	*/
+	setPromptStatus(status: string): boolean;
+	/**
+	* Toggle a floating-overlay toolbar control by its widget `key`. The host
+	* owns the toggle's checked state, flips it in place, and emits a
+	* `widget_event` (`event_type: "toggle"`, payload `{ checked }`). Use this
+	* to route a plugin's own keyboard shortcut through the same host path as
+	* a click or Space on the toggle, then react in your `widget_event` handler.
+	*/
+	toggleOverlayToolbarWidget(key: string): boolean;
+	/**
 	* Override the currently-highlighted suggestion row in the
 	* open prompt. The editor clamps `index` to the suggestion
 	* list's bounds and the renderer scrolls it into view on
@@ -2774,6 +2890,16 @@ interface EditorAPI {
 	*/
 	clearAuthority(): void;
 	/**
+	* Activate an environment: set the live env recipe (`snippet` run in
+	* `dir`). Applied to every spawn, re-evaluated on demand — no restart.
+	* Honored only when the workspace is Trusted.
+	*/
+	setEnv(snippet: string, dir: string | null): void;
+	/**
+	* Deactivate the environment — spawns return to the inherited env.
+	*/
+	clearEnv(): void;
+	/**
 	* Override the Remote Indicator's displayed state. Plugins call
 	* this to surface lifecycle transitions that the authority layer
 	* doesn't know about yet — "Connecting" while `devcontainer up`
@@ -2799,6 +2925,19 @@ interface EditorAPI {
 	*/
 	clearRemoteIndicatorState(): void;
 	/**
+	* Fetch a URL over HTTP(S) and stream the response body into `target_path`.
+	* 
+	* Resolves with a `SpawnResult`-shaped value: `exit_code` is `0` on a
+	* 2xx response (file written), the HTTP status code on non-2xx
+	* (target file untouched), and `-1` on transport errors. `stderr`
+	* carries an error message in the non-success cases; `stdout` is
+	* always empty.
+	* 
+	* This uses the editor's built-in HTTP client (`ureq`), so plugins
+	* don't need `curl`/`wget` on PATH.
+	*/
+	httpFetch(url: string, targetPath: string): ProcessHandle<SpawnResult>;
+	/**
 	* Wait for a process to complete and get its result (async)
 	*/
 	spawnProcessWait(processId: number): Promise<SpawnResult>;
@@ -2851,6 +2990,14 @@ interface EditorAPI {
 	*/
 	createTerminal(opts?: CreateTerminalOptions): Promise<TerminalResult>;
 	/**
+	* Create a new editor window seeded with an agent terminal as
+	* its only buffer. Atomic — replaces the legacy
+	* `createWindow` + `setActiveWindow` + `createTerminal`
+	* chain that left a transient `[No Name]` tab alongside the
+	* agent terminal.
+	*/
+	createWindowWithTerminal(opts: CreateWindowWithTerminalOptions): Promise<SessionWithTerminalResult>;
+	/**
 	* Send input data to a terminal
 	*/
 	sendTerminalInput(terminalId: number, data: string): boolean;

package/plugins/lib/widgets.ts

@@ -60,6 +60,14 @@ export function row(...children: WidgetSpec[]): WidgetSpec {
   return { kind: "row", children };
 }
 
+/** Horizontal layout that **wraps**: children that don't fit on one line
+ * reflow onto additional lines (growing the row's height) instead of being
+ * truncated. Children are never split, so wrap a logical group (e.g. a
+ * toggle + its accelerator) in a nested `row(...)` to keep it intact. */
+export function wrappingRow(...children: WidgetSpec[]): WidgetSpec {
+  return { kind: "row", children, wrap: true };
+}
+
 /** Vertical layout. Children stacked top-to-bottom. */
 export function col(...children: WidgetSpec[]): WidgetSpec {
   return { kind: "col", children };

package/plugins/live_diff.ts

@@ -38,19 +38,18 @@ const PRIORITY = 9;
 
 // Theme keys for backgrounds and "on top of bg" foregrounds. These
 // are resolved at render time by the editor, so the diff colors track
-// the active theme automatically. The `editor.diff_*_fg` keys are
-// purpose-built for "text drawn on top of the matching diff bg" —
-// they default to `ui.file_status_*_fg` so themes that haven't been
-// updated still work, but themes whose `file_status_*_fg` collides
-// with `diff_*_bg` (e.g. `terminal`, where both resolve to ANSI Red)
-// override `editor.diff_*_fg` to a contrasting color.
+// the active theme automatically. The `editor.diff_*_collision_fg`
+// keys pair with `fgOnCollisionOnly: true` below: themes that define
+// them get a contrasting fg painted only on cells whose syntax fg
+// happens to match the diff bg (e.g. ANSI Green-on-Green); every
+// other cell keeps its syntax colour.
 const THEME = {
   addedBg: "editor.diff_add_bg",
-  addedFg: "editor.diff_add_fg",
+  addedFg: "editor.diff_add_collision_fg",
   modifiedBg: "editor.diff_modify_bg",
-  modifiedFg: "editor.diff_modify_fg",
+  modifiedFg: "editor.diff_modify_collision_fg",
   removedBg: "editor.diff_remove_bg",
-  removedFg: "editor.diff_remove_fg",
+  removedFg: "editor.diff_remove_collision_fg",
 };
 
 // `setLineIndicator` only accepts RGB triples (not theme keys), so the
@@ -845,14 +844,9 @@ function renderHunks(state: BufferDiffState, newLines: string[]): void {
   for (const h of state.hunks) {
     if (h.kind === "added" || h.kind === "modified") {
       const bg = h.kind === "added" ? THEME.addedBg : THEME.modifiedBg;
-      // Passing `fg` as a theme key lets each theme decide whether to
-      // override the cell's existing fg: themes that DEFINE
-      // `editor.diff_*_fg` (e.g. `terminal`, where the ANSI bg would
-      // otherwise collide with same-named syntax colors) get a
-      // contrasting fg painted on; themes that don't define the key
-      // resolve to `None` in `OverlayFace::ThemedStyle`, so the
-      // overlay leaves the cell's fg alone and syntax highlighting
-      // shows through unchanged.
+      // `fgOnCollisionOnly` keeps syntax highlighting intact on the
+      // rest of the line and only paints `fg` where a token's colour
+      // would otherwise be invisible against the diff bg.
       const fg = h.kind === "added" ? THEME.addedFg : THEME.modifiedFg;
       for (let i = 0; i < h.newCount; i++) {
         const line = h.newStart + i;
@@ -871,6 +865,7 @@ function renderHunks(state: BufferDiffState, newLines: string[]): void {
         editor.addOverlay(bid, NS_OVERLAY, start, end, {
           bg,
           fg,
+          fgOnCollisionOnly: true,
           underline: false,
           bold: false,
           italic: false,