@fresh-editor/fresh-editor 0.3.6 → 0.3.8

package/plugins/audit_mode.ts

@@ -1743,7 +1743,30 @@ function applyCursorLineOverlay(panel: 'diff'): void {
     });
 }
 
-function review_refresh() { refreshMagitData(); }
+function review_refresh() {
+    // Synchronously acknowledge the keypress before kicking off the
+    // async `git status` + `git diff`. Those calls take long enough on
+    // a non-trivial repo that, without this immediate status update,
+    // the sticky-header totals visibly lag the new content: users
+    // press `r`, see the old `+N / -M`, conclude the keystroke was
+    // dropped, and press `r` again — which then "appears" to work
+    // because the first refresh has by then landed. See #2036.
+    //
+    // In range mode the refresh is intentionally a no-op for
+    // working-tree edits (the diff is always between two refs); the
+    // range-specific message explains that up front so the user
+    // doesn't think `r` is broken when their unstaged changes don't
+    // show up.
+    if (state.mode === 'range' && state.range) {
+        editor.setStatus(
+            editor.t("status.refreshing_range", { range: state.range.label }) ||
+                `Refreshing ${state.range.label}... (working tree not included)`
+        );
+    } else {
+        editor.setStatus(editor.t("status.refreshing") || "Refreshing review diff...");
+    }
+    void refreshMagitData();
+}
 registerHandler("review_refresh", review_refresh);
 
 // --- Cursor-driven navigation ---
@@ -3163,13 +3186,21 @@ function updateReviewStatus(): void {
     if (state.groupId === null) return;
     const total = state.hunkHeaderRows.length;
     const current = currentGlobalHunkIndex();
+    // Range reviews fundamentally don't include working-tree edits; the
+    // suffix makes that visible from the status bar at all times rather
+    // than only flashing past during a refresh. Without it users hit `r`,
+    // see their unsaved changes don't appear, and conclude the refresh is
+    // broken (#2036).
+    const rangeNote = state.mode === 'range' && state.range
+        ? ` · ${editor.t("status.working_tree_not_included") || "working tree not included"}`
+        : '';
     if (current !== null) {
         editor.setStatus(editor.t("status.review_summary_indexed", {
             current: String(current),
             count: String(total),
-        }));
+        }) + rangeNote);
     } else {
-        editor.setStatus(editor.t("status.review_summary", { count: String(total) }));
+        editor.setStatus(editor.t("status.review_summary", { count: String(total) }) + rangeNote);
     }
 }
 
@@ -4640,13 +4671,121 @@ async function review_branch_refresh(): Promise<void> {
 }
 registerHandler("review_branch_refresh", review_branch_refresh);
 
-/** Enter: focus the detail panel (so the user can scroll/click within it). */
+/** Is the detail panel the currently-focused buffer? */
+function isReviewBranchDetailFocused(): boolean {
+    return (
+        branchState.detailBufferId !== null &&
+        editor.getActiveBufferId() === branchState.detailBufferId
+    );
+}
+
+/** The currently-selected commit in the log panel, or null. */
+function selectedReviewBranchCommit(): GitCommit | null {
+    if (branchState.commits.length === 0) return null;
+    const i = Math.max(
+        0,
+        Math.min(branchState.selectedIndex, branchState.commits.length - 1),
+    );
+    return branchState.commits[i] ?? null;
+}
+
+/**
+ * Enter: on the log panel jumps focus into the detail panel; on the detail
+ * panel opens the file at the cursor position at the selected commit (if any).
+ */
 function review_branch_enter(): void {
     if (branchState.groupId === null) return;
+    if (isReviewBranchDetailFocused()) {
+        void review_branch_detail_open_file();
+        return;
+    }
     editor.focusBufferGroupPanel(branchState.groupId, "detail");
 }
 registerHandler("review_branch_enter", review_branch_enter);
 
+/**
+ * Open the file at the cursor's `(file, line)` text-properties at the
+ * currently-selected commit, in a read-only virtual buffer. Mirrors the
+ * git-log plugin's `git_log_detail_open_file` so users get the same
+ * drill-down from the review-branch detail panel.
+ */
+async function review_branch_detail_open_file(): Promise<void> {
+    if (branchState.detailBufferId === null) return;
+    const commit = selectedReviewBranchCommit();
+    if (!commit) return;
+
+    const props = editor.getTextPropertiesAtCursor(branchState.detailBufferId);
+    if (props.length === 0) {
+        editor.setStatus(editor.t("status.move_to_diff"));
+        return;
+    }
+    const file = props[0].file as string | undefined;
+    const line = (props[0].line as number | undefined) ?? 1;
+    if (!file) {
+        editor.setStatus(editor.t("status.move_to_diff_with_context"));
+        return;
+    }
+
+    editor.setStatus(
+        editor.t("status.file_loading", { file, hash: commit.shortHash }),
+    );
+    const result = await editor.spawnProcess("git", [
+        "show",
+        `${commit.hash}:${file}`,
+    ]);
+    if (result.exit_code !== 0) {
+        editor.setStatus(
+            editor.t("status.file_not_found", { file, hash: commit.shortHash }),
+        );
+        return;
+    }
+
+    const lines = result.stdout.split("\n");
+    const entries: TextPropertyEntry[] = lines.map((l, i) => ({
+        text: l + (i < lines.length - 1 ? "\n" : ""),
+        properties: { type: "content", line: i + 1 },
+    }));
+
+    // `*<hash>:<path>*` matches the virtual-name convention the host uses
+    // to detect syntax from the trailing filename's extension.
+    const name = `*${commit.shortHash}:${file}*`;
+    const view = await editor.createVirtualBuffer({
+        name,
+        mode: "review-branch-file-view",
+        readOnly: true,
+        editingDisabled: true,
+        showLineNumbers: true,
+        entries,
+    });
+    if (view) {
+        const byte = await editor.getLineStartPosition(Math.max(0, line - 1));
+        if (byte !== null) editor.setBufferCursor(view.bufferId, byte);
+        editor.setStatus(
+            editor.t("status.file_view_ready", {
+                file,
+                hash: commit.shortHash,
+                line: String(line),
+            }),
+        );
+    } else {
+        editor.setStatus(editor.t("status.failed_open_file", { file }));
+    }
+}
+registerHandler(
+    "review_branch_detail_open_file",
+    review_branch_detail_open_file,
+);
+
+/** Tab: toggle focus between the log and detail panels. */
+function review_branch_tab(): void {
+    if (branchState.groupId === null) return;
+    editor.focusBufferGroupPanel(
+        branchState.groupId,
+        isReviewBranchDetailFocused() ? "log" : "detail",
+    );
+}
+registerHandler("review_branch_tab", review_branch_tab);
+
 /** q/Escape: focus-back from detail, or close when already on log. */
 function review_branch_close_or_back(): void {
     if (branchState.groupId === null) return;
@@ -4683,9 +4822,11 @@ editor.defineMode(
         // from the Normal keymap via `inheritNormalBindings: true`.
         ["k", "move_up"],
         ["j", "move_down"],
-        // Enter: focus the right-hand detail panel.
+        // Enter: from the log, focus the detail panel; from the detail
+        // panel, open the file at the cursor at the selected commit.
         ["Return", "review_branch_enter"],
-        ["Tab", "review_branch_enter"],
+        // Tab: toggle focus between the log and detail panels.
+        ["Tab", "review_branch_tab"],
         ["r", "review_branch_refresh"],
         ["q", "review_branch_close_or_back"],
         ["Escape", "review_branch_close_or_back"],
@@ -4695,6 +4836,32 @@ editor.defineMode(
     true, // inheritNormalBindings — PageUp/PageDown/arrows/Home/End come from Normal
 );
 
+/** Close the file-view virtual buffer opened from the review-branch detail panel. */
+function review_branch_file_view_close(): void {
+    const id = editor.getActiveBufferId();
+    if (id) editor.closeBuffer(id);
+}
+registerHandler("review_branch_file_view_close", review_branch_file_view_close);
+
+// Mode for the read-only "git show <hash>:<file>" buffer opened from the
+// review-branch detail panel. Mirrors git-log's `git-log-file-view`:
+// q/Escape close the view, j/k alias Up/Down, and all other Normal
+// bindings (arrows, PageUp/Down, Home/End, Ctrl+C copy) are inherited so
+// unbound keys don't fall through to edit actions and trip the
+// `editing_disabled` status message (see #566).
+editor.defineMode(
+    "review-branch-file-view",
+    [
+        ["k", "move_up"],
+        ["j", "move_down"],
+        ["q", "review_branch_file_view_close"],
+        ["Escape", "review_branch_file_view_close"],
+    ],
+    true, // read-only
+    false, // allow_text_input
+    true, // inherit Normal-context bindings for unbound keys
+);
+
 // Register Modes and Commands
 editor.registerCommand("%cmd.review_diff", "%cmd.review_diff_desc", "start_review_diff", null);
 editor.registerCommand("%cmd.review_branch", "%cmd.review_branch_desc", "start_review_branch", null);

package/plugins/config-schema.json

@@ -103,6 +103,7 @@
         "auto_save_enabled": false,
         "auto_save_interval_secs": 30,
         "hot_exit": true,
+        "confirm_quit": false,
         "restore_previous_session": true,
         "skip_session_restore_when_files_passed": true,
         "auto_create_empty_buffer_on_last_buffer_close": true,
@@ -134,7 +135,10 @@
         "preview_tabs": true,
         "side": "left",
         "auto_open_on_last_buffer_close": true,
-        "follow_active_buffer": false
+        "follow_active_buffer": false,
+        "compact_directories": true,
+        "tree_indicator_collapsed": ">",
+        "tree_indicator_expanded": "▼"
       }
     },
     "file_browser": {
@@ -652,6 +656,12 @@
           "default": true,
           "x-section": "Recovery"
         },
+        "confirm_quit": {
+          "description": "Whether to confirm before quitting Fresh. When enabled, pressing\nthe quit shortcut surfaces a confirmation prompt even when no\nbuffers are modified. Useful for users who frequently hit\n`Ctrl+Q` by mistake. Independent of the unsaved-changes prompt,\nwhich always fires regardless of this setting.\nDefault: false",
+          "type": "boolean",
+          "default": false,
+          "x-section": "Startup"
+        },
         "restore_previous_session": {
           "description": "Whether to auto-open previously opened files (session restore) when\nstarting Fresh in a directory.  When enabled (the default), tabs,\nsplits, cursor positions and the file explorer state are restored\nfrom the last clean exit in the same working directory.  When\ndisabled, Fresh starts with a clean workspace.  The workspace file\non disk is still written on exit, so re-enabling this setting picks\nup whatever state was saved at the most recent clean exit.  The\n`--no-restore` CLI flag is a stronger override: it skips both\nrestoring and saving the workspace.\nDefault: true",
           "type": "boolean",
@@ -793,7 +803,8 @@
             "{messages}"
           ],
           "x-section": "Status Bar",
-          "x-dual-list-sibling": "/editor/status_bar/right"
+          "x-dual-list-sibling": "/editor/status_bar/right",
+          "x-dynamically-extendable-status-bar-elements": true
         },
         "right": {
           "description": "Elements shown on the right side of the status bar.\nDefault: [\"{line_ending}\", \"{encoding}\", \"{language}\", \"{lsp}\", \"{warnings}\", \"{update}\", \"{palette}\"]",
@@ -811,7 +822,8 @@
             "{palette}"
           ],
           "x-section": "Status Bar",
-          "x-dual-list-sibling": "/editor/status_bar/left"
+          "x-dual-list-sibling": "/editor/status_bar/left",
+          "x-dynamically-extendable-status-bar-elements": true
         }
       }
     },
@@ -958,6 +970,21 @@
           "description": "When the file explorer sidebar is open, automatically expand the\ntree and highlight the file that corresponds to the active buffer\nwhenever you switch tabs. Set to `true` to keep the explorer\nselection in sync with the active tab.\nDefault: false",
           "type": "boolean",
           "default": false
+        },
+        "compact_directories": {
+          "description": "Render single-child directory chains on a single line, e.g.\n`src/main/java/com/example`. Only applies when each intermediate\ndirectory in the chain is expanded and has exactly one visible\nchild that is itself a directory. Mirrors VSCode's\n`explorer.compactFolders`.\nDefault: true",
+          "type": "boolean",
+          "default": true
+        },
+        "tree_indicator_collapsed": {
+          "description": "Symbol shown next to a collapsed (closed) directory in the file\nexplorer tree. A short string (single character recommended).\nA trailing space is added automatically during rendering; the\nrenderer pads narrower indicators so collapsed/expanded rows align.\nDefault: \">\"",
+          "type": "string",
+          "default": ">"
+        },
+        "tree_indicator_expanded": {
+          "description": "Symbol shown next to an expanded (open) directory in the file\nexplorer tree. A short string (single character recommended).\nA trailing space is added automatically during rendering; the\nrenderer pads narrower indicators so collapsed/expanded rows align.\nDefault: \"▼\"",
+          "type": "string",
+          "default": "▼"
         }
       }
     },
@@ -1643,6 +1670,10 @@
             "null"
           ],
           "readOnly": true
+        },
+        "settings": {
+          "description": "Plugin-specific settings. The shape is defined by each plugin's\n`<plugin_name>.schema.json` sidecar file; the host stores the value as\nuntyped JSON so a malformed plugin schema can't poison the rest of the\nconfig. Plugins read this via `editor.getPluginConfig()` and the\nSettings UI renders it as a sub-category under \"Plugin Settings\".",
+          "readOnly": true
         }
       },
       "x-display-field": "/enabled"

package/plugins/dashboard.ts

@@ -1586,18 +1586,20 @@ async function dashboardShowOrFocus() {
 registerHandler("dashboardShowOrFocus", dashboardShowOrFocus);
 
 // Auto-open resolution: the session override (set via the exported
-// plugin API from init.ts) wins over the user config. We read from
-// getUserConfig (raw file) rather than getConfig because unknown
-// fields are dropped when the Config struct reserializes. Default
-// is true.
+// plugin API from init.ts) wins over the user-configured value, which
+// comes from the typed plugin-config field declared below. The field
+// shows up in the Settings UI under "Plugin Settings → dashboard".
+editor.defineConfigBoolean("autoOpen", {
+    default: true,
+    description: "Show the dashboard automatically when Fresh starts with no real files open.",
+});
+
 let autoOpenOverride: boolean | null = null;
 
 function autoOpenEnabled(): boolean {
     if (autoOpenOverride !== null) return autoOpenOverride;
-    const cfg = editor.getUserConfig() as Record<string, unknown> | null;
-    const plugins = cfg?.plugins as Record<string, unknown> | undefined;
-    const dashboard = plugins?.dashboard as Record<string, unknown> | undefined;
-    return dashboard?.["auto-open"] !== false;
+    const cfg = (editor.getPluginConfig() ?? {}) as { autoOpen?: boolean };
+    return cfg.autoOpen !== false;
 }
 
 function shouldShowDashboard(): boolean {
@@ -1801,12 +1803,14 @@ editor.exportPluginApi("dashboard", {
 // `plugins.dashboard.enabled` is true in the resolved config — so the
 // standard settings UI is the single enable/disable surface.
 //
-// If the plugin loads mid-session (user toggles it on in Settings),
-// the `ready` hook has already fired, so we also run an immediate
-// check. At startup the `listBuffers().length > 0` guard keeps us
-// dormant until the workspace has actually restored: plugins load
-// before restore, and opening a buffer here would race with the
-// restore and leave a stray Dashboard tab even when real files exist.
+// Auto-open is driven exclusively by the `ready` hook (and the
+// `buffer_closed` handler for the last-tab-closed case). We
+// deliberately do NOT auto-open at module load: dashboard.ts loads
+// during the startup plugin batch, *before* the user's init.ts has
+// been evaluated, so an immediate auto-open would race
+// `setAutoOpen(false)` and dismiss the user's preference. Users who
+// hot-load the plugin mid-session (toggle on in Settings) get the
+// dashboard via the "Show Dashboard" command in the palette.
 editor.on("ready", "dashboardOnReady");
 editor.on("buffer_closed", "dashboardOnBufferClosed");
 editor.on("viewport_changed", "dashboardOnViewportChanged");
@@ -1820,7 +1824,3 @@ editor.registerCommand(
     "Open the dashboard, or bring it to the front if it's already open",
     "dashboardShowOrFocus",
 );
-
-if (editor.listBuffers().length > 0 && shouldShowDashboard()) {
-    openDashboard();
-}

package/plugins/env-manager.ts

@@ -0,0 +1,168 @@
+/// <reference path="./lib/fresh.d.ts" />
+
+/**
+ * Environment Manager
+ *
+ * Detects a project's environment manager (Python venv, direnv, mise) and
+ * activates it by handing core an activation **snippet** via `editor.setEnv`.
+ * Core captures the resulting environment on the active backend (local / SSH)
+ * and applies it to every editor-spawned process — language servers,
+ * formatters, `spawnProcess`.
+ *
+ * Detection is passive (reads files only). Activation runs repo-controlled
+ * code, so it is gated on Workspace Trust: the plugin only calls `setEnv` when
+ * `editor.workspaceTrustLevel() === "trusted"` (and core enforces the same).
+ *
+ * Freshness: one-shot spawns re-capture automatically when the env inputs
+ * change (core's cache is keyed on them). A long-running language server has
+ * its env fixed at spawn, so to pick up a changed `.envrc`/`mise.toml` the
+ * user runs **Env: Reload**, which re-captures and restarts servers. (Auto
+ * file-watching is intentionally not wired yet.)
+ */
+
+const editor = getEditor();
+
+const STATUS_TOKEN = "env";
+
+interface Detected {
+  /** Short label for the status pill, e.g. ".venv" / "direnv" / "mise". */
+  name: string;
+  /** The activation snippet handed to `editor.setEnv`. */
+  snippet: string;
+}
+
+function fileExists(p: string): boolean {
+  try {
+    return editor.fileExists(p);
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Detect the environment in the current workspace and return its activation
+ * snippet, or null if none. These are auto-detected default snippets; direnv
+ * and mise need their exporters (they're prompt-hook driven), venv sources its
+ * activate script, and anything else is a pure login shell / user snippet.
+ */
+function detect(): Detected | null {
+  const cwd = editor.getCwd();
+  if (!cwd) return null;
+
+  for (const name of [".venv", "venv"]) {
+    const dir = editor.pathJoin(cwd, name);
+    if (
+      fileExists(editor.pathJoin(dir, "bin", "python")) ||
+      fileExists(editor.pathJoin(dir, "bin", "python3")) ||
+      fileExists(editor.pathJoin(dir, "Scripts", "python.exe"))
+    ) {
+      return { name, snippet: `source ${editor.pathJoin(dir, "bin", "activate")}` };
+    }
+  }
+
+  if (fileExists(editor.pathJoin(cwd, ".envrc"))) {
+    return { name: "direnv", snippet: `eval "$(direnv export bash)"` };
+  }
+
+  for (const name of ["mise.toml", ".mise.toml", ".tool-versions"]) {
+    if (fileExists(editor.pathJoin(cwd, name))) {
+      return { name: "mise", snippet: `eval "$(mise env -s bash)"` };
+    }
+  }
+
+  return null;
+}
+
+function isTrusted(): boolean {
+  return editor.workspaceTrustLevel() === "trusted";
+}
+
+// === Commands ===
+
+/** Activate (or, when already active, reload) the detected environment. */
+function activate(): void {
+  if (!isTrusted()) {
+    editor.setStatus(
+      "Workspace not trusted — run “Workspace Trust: Trust This Folder” to activate the environment",
+    );
+    return;
+  }
+  const det = detect();
+  if (!det) {
+    editor.setStatus("No environment manager detected in this project");
+    return;
+  }
+  // Core captures `snippet` on the active backend and applies it to every
+  // spawn; it restarts so language servers re-spawn under the fresh env.
+  editor.setEnv(det.snippet, editor.getCwd());
+  editor.setStatus(
+    `${editor.envActive() ? "Reloading" : "Activating"} ${det.name} environment…`,
+  );
+}
+registerHandler("env_activate_handler", activate);
+
+function useSystem(): void {
+  editor.clearEnv();
+  editor.setStatus("Environment deactivated — using the system environment");
+}
+registerHandler("env_use_system_handler", useSystem);
+
+function showStatus(): void {
+  const det = detect();
+  const trust = editor.workspaceTrustLevel() || "unavailable";
+  if (editor.envActive()) {
+    editor.setStatus(`Environment active${det ? ` (${det.name})` : ""}`);
+  } else if (det) {
+    editor.setStatus(
+      `Detected ${det.name} (trust: ${trust}). Run “Env: Activate” to use it.`,
+    );
+  } else {
+    editor.setStatus(`No environment detected (trust: ${trust})`);
+  }
+}
+registerHandler("env_status_handler", showStatus);
+
+editor.registerCommand(
+  "env_activate",
+  "Env: Activate Detected Environment (venv / direnv / mise)",
+  "env_activate_handler",
+);
+editor.registerCommand(
+  "env_reload",
+  "Env: Reload Environment (re-capture after .envrc/mise.toml change)",
+  "env_activate_handler",
+);
+editor.registerCommand(
+  "env_use_system",
+  "Env: Use System (Deactivate Environment)",
+  "env_use_system_handler",
+);
+editor.registerCommand(
+  "env_status",
+  "Env: Show Environment Status",
+  "env_status_handler",
+);
+
+// === Status pill (opt-in to a user's status-bar layout) ===
+
+function refreshStatus(): void {
+  const bufferId = editor.getActiveBufferId();
+  if (bufferId === 0) return;
+  const det = detect();
+  let value: string;
+  if (editor.envActive()) {
+    value = det ? `${det.name} ✓` : "active";
+  } else {
+    value = det ? `${det.name}${isTrusted() ? "" : " (locked)"}` : "system";
+  }
+  editor.setStatusBarValue(bufferId, STATUS_TOKEN, value);
+}
+
+editor.registerStatusBarElement(STATUS_TOKEN, "Environment");
+
+registerHandler("env_refresh_status", refreshStatus);
+for (const event of ["buffer_activated", "after_file_open", "focus_gained"]) {
+  editor.on(event, "env_refresh_status");
+}
+
+refreshStatus();

package/plugins/flash.ts

@@ -33,7 +33,24 @@ const VTEXT_PREFIX = "flash-";
 // the closest jump targets get the most comfortable keys.  All
 // lowercase: case-sensitive matching keeps the label letter from also
 // being a valid pattern continuation, which matters for the skip rule.
-const LABEL_POOL = "asdfghjklqwertyuiopzxcvbnm";
+editor.defineConfigString("labelPool", {
+  default: "asdfghjklqwertyuiopzxcvbnm",
+  description: "Characters used as jump labels, in comfort order. Labels are assigned to matches by distance from the cursor, so leftmost characters here land on the nearest matches.",
+});
+editor.defineConfigBoolean("skipRule", {
+  default: true,
+  description: "Skip a label character if it is also the next character after a match — prevents ambiguity between extending the search pattern and jumping.",
+});
+
+function flashSettings(): { labelPool: string; skipRule: boolean } {
+  const cfg = (editor.getPluginConfig() ?? {}) as { labelPool?: string; skipRule?: boolean };
+  return {
+    labelPool: cfg.labelPool && cfg.labelPool.length > 0
+      ? cfg.labelPool
+      : "asdfghjklqwertyuiopzxcvbnm",
+    skipRule: cfg.skipRule ?? true,
+  };
+}
 
 interface Match {
   /** Byte offset where the match starts in its buffer. */
@@ -334,9 +351,10 @@ function assignLabels(
   prevLabelByKey: Map<string, string>,
 ): Match[] {
   if (matches.length === 0) return matches;
-  const skip = buildSkipSet(matches, views, emptyPattern);
+  const { labelPool, skipRule } = flashSettings();
+  const skip = skipRule ? buildSkipSet(matches, views, emptyPattern) : new Set<string>();
   const remaining = new Set<string>();
-  for (const c of LABEL_POOL) if (!skip.has(c)) remaining.add(c);
+  for (const c of labelPool) if (!skip.has(c)) remaining.add(c);
 
   const sorted = sortMatches(matches, startSplitId, startCursor);
 
@@ -353,7 +371,7 @@ function assignLabels(
   // matches in distance order.  Iterate the pool in its native
   // (comfort-ranked) order so home-row letters go to nearest matches.
   const orderedRemaining: string[] = [];
-  for (const c of LABEL_POOL) if (remaining.has(c)) orderedRemaining.push(c);
+  for (const c of labelPool) if (remaining.has(c)) orderedRemaining.push(c);
   let next = 0;
   for (const m of sorted) {
     if (m.label) continue;

package/plugins/git_blame.ts

@@ -87,10 +87,13 @@ const blameState: BlameState = {
 // Color Definitions for Header Styling
 // =============================================================================
 
-const colors = {
-  headerFg: [0, 0, 0] as [number, number, number],           // Black text
-  headerBg: [200, 200, 200] as [number, number, number],     // Light gray background
-};
+// Blame headers are rendered via `addVirtualLine`, which accepts theme
+// keys directly — so we don't expose colors as plugin settings. Themes
+// drive the look; if a theme lacks specific blame keys, these fall
+// through to the editor's status-bar palette which is what every theme
+// defines.
+const HEADER_FG_KEY = "ui.status_bar_fg";
+const HEADER_BG_KEY = "ui.status_bar_bg";
 
 // =============================================================================
 // Mode Definition
@@ -373,7 +376,8 @@ function addBlameHeaders(): void {
   // Clear existing headers first
   editor.clearVirtualTextNamespace(blameState.bufferId, BLAME_NAMESPACE);
 
-  // Add a virtual line above each block
+  // Add a virtual line above each block. Pass theme keys so the headers
+  // restyle automatically when the user switches themes.
   for (const block of blameState.blocks) {
     const headerText = formatBlockHeader(block);
 
@@ -381,7 +385,7 @@ function addBlameHeaders(): void {
       blameState.bufferId,
       block.startByte,        // anchor position
       headerText,             // text content
-      { fg: colors.headerFg, bg: colors.headerBg }, // colors (RGB tuples; passing theme key strings would also work)
+      { fg: HEADER_FG_KEY, bg: HEADER_BG_KEY },
       true,                   // above (LineAbove)
       BLAME_NAMESPACE,        // namespace for bulk removal
       0                       // priority