diff --git a/.vscode/settings.json b/.vscode/settings.json
index 7f05584..30c35ea 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -12,6 +12,9 @@
         "editor.defaultFormatter": "biomejs.biome",
         "editor.formatOnSave": true
     },
+    "[json]": {
+        "editor.defaultFormatter": "vscode.json-language-features"
+    },
     // Exclude common build and cache directories from the file explorer
     "files.exclude": {
         "**/.git": true,
@@ -102,9 +105,7 @@
         "webfonts",
         "wmii"
     ],
-    "[json]": {
-        "editor.defaultFormatter": "vscode.json-language-features"
-    },
+    // Import settings
     "javascript.preferences.importModuleSpecifier": "shortest",
     "typescript.preferences.importModuleSpecifier": "non-relative"
 }
diff --git a/eslint.config.mjs b/eslint.config.mjs
index fd9189d..ddd2b39 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -2,7 +2,7 @@ import nitpicker from "@alien_intelligence/eslint-plugin-nitpicker"
 import tsParser from "@typescript-eslint/parser"
 
 /**
- * ESLint flat config, layers Nitpicker on top of Biome for nit-level enforcement,
+ * ESLint flat config, it exists only to host Nitpicker for nit-level enforcement,
  * Biome still owns formatting and the broader lint rules.
  */
 export default [
@@ -14,15 +14,28 @@ export default [
             sourceType: "module",
         },
         plugins: { nitpicker },
-        rules: {
-            ...nitpicker.configs.recommended.rules,
-            // TODO: re-enable once the upstream `e.charAt is not a function` crash is fixed,
-            // it currently trips on any TS `import type` line and aborts the whole lint run.
-            "nitpicker/no-british-english": "off",
-        },
+        rules: nitpicker.configs.recommended.rules,
+    },
+    {
+        files: ["src/**/*.ts", "src/**/*.tsx"],
+        ...nitpicker.configs.breathing,
     },
     {
         files: ["src/renderer/**/*.tsx", "src/renderer/**/*.ts"],
         ...nitpicker.configs.react,
     },
+    {
+        files: ["src/renderer/**/*.tsx"],
+        ignores: ["src/renderer/components/ui/**"],
+        ...nitpicker.configs.design,
+        rules: {
+            ...nitpicker.configs.design.rules,
+            // The react95 "Button" is beveled window chrome, a flat list row or theme
+            // option is a "<button>" for the semantics alone and must not carry it
+            "nitpicker/no-raw-control-element": [
+                "warn",
+                { allowIn: ["**/rows/FlatResults.tsx", "**/preferences/AppearanceTab.tsx"] },
+            ],
+        },
+    },
 ]
diff --git a/package.json b/package.json
index 2a9822f..02374ab 100644
--- a/package.json
+++ b/package.json
@@ -46,7 +46,7 @@
         "styled-components": "^6.4.3"
     },
     "devDependencies": {
-        "@alien_intelligence/eslint-plugin-nitpicker": "^0.2.0",
+        "@alien_intelligence/eslint-plugin-nitpicker": "^0.10.1",
         "@biomejs/biome": "^2.5.2",
         "@tailwindcss/vite": "^4.3.1",
         "@types/node": "^24.12.2",
diff --git a/src/main/config/app.ts b/src/main/config/app.ts
index af625c1..22d9e3e 100644
--- a/src/main/config/app.ts
+++ b/src/main/config/app.ts
@@ -14,6 +14,7 @@ const DEFAULT_APP_CONFIG: AppConfig = {
     preferences: {
         theme: "original",
         startupBehavior: "reopen-last",
+        codeEditorPath: "", // Empty means the installed editors are detected instead
         autoLockTickIntervalMs: AUTO_LOCK_CONFIG.tickIntervalMs,
         mcpEndpoint: MCP_CONFIG.endpoint,
         mcpProbeIntervalMs: MCP_CONFIG.probeIntervalMs,
diff --git a/src/main/config/windows.ts b/src/main/config/windows.ts
index b6312af..6b90e50 100644
--- a/src/main/config/windows.ts
+++ b/src/main/config/windows.ts
@@ -61,7 +61,7 @@ const WINDOWS_CONFIG: {
         icon: appIcon,
         webPreferences: WEB_PREFERENCES,
     },
-    // Sized per variant by the dialogs service, from `DIALOGS_CONFIG`
+    // Sized per variant by the dialogs service, from "DIALOGS_CONFIG"
     dialog: SECONDARY_WINDOW,
     preferences: {
         ...SECONDARY_WINDOW,
diff --git a/src/main/index.ts b/src/main/index.ts
index ddd4d59..08aabef 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -63,20 +63,28 @@ async function createMainWindow(): Promise<BrowserWindow> {
 
 // Create the main application window when Electron is ready
 app.whenReady().then(async () => {
-    // Handlers
+    // Handlers, the app shell itself
     registerAppHandlers()
     registerWindowsControlHandlers()
     registerDialogsHandlers()
+
+    // Handlers reaching the repository
     registerGitCommandsHandlers()
     registerLfsCommandsHandlers()
     registerFileTreeHandlers()
+
+    // Handlers reaching the project on disk
     registerProjectsHandlers()
     registerUProjectHandlers()
     registerShellsHandlers()
+
+    // Handlers backing the long-running services
     registerUpdaterHandlers()
     registerMcpHandlers()
     registerAutoLockHandlers()
     registerCompileDbHandlers()
+
+    // Handlers owning the persisted state
     registerViewStateHandlers()
     registerPreferencesHandlers()
 
diff --git a/src/main/lib/compileDb/paths.ts b/src/main/lib/compileDb/paths.ts
index 91593c6..1f2b867 100644
--- a/src/main/lib/compileDb/paths.ts
+++ b/src/main/lib/compileDb/paths.ts
@@ -42,6 +42,7 @@ function isInsideSourceTree(posixPath: string): boolean {
     const segments = posixPath.split("/")
 
     if (segments[0] === COMPILE_DB_CONFIG.sourceRootDirName) return true
+
     if (segments[0] === COMPILE_DB_CONFIG.pluginsDirName) {
         return segments.slice(2).includes(COMPILE_DB_CONFIG.sourceRootDirName)
     }
@@ -62,7 +63,7 @@ export function classifySourcePath(relativePath: string): CompileDbFileKind | nu
 
     const extension = path.posix.extname(posixPath).toLowerCase()
 
-    // A plugin's own descriptor sits above its `Source` tree rather than inside it,
+    // A plugin's own descriptor sits above its "Source" tree rather than inside it,
     // and enabling a module in one moves the build with no source file moving
     if (extension === COMPILE_DB_CONFIG.pluginDescriptorExtension) {
         return isInsidePlugins(posixPath) ? "descriptor" : null
diff --git a/src/main/lib/compileDb/service.ts b/src/main/lib/compileDb/service.ts
index ef6c22a..694d1ad 100644
--- a/src/main/lib/compileDb/service.ts
+++ b/src/main/lib/compileDb/service.ts
@@ -208,10 +208,9 @@ export class CompileDbService {
         this._knownFiles = next
         compileDbStore.set({ trackedFileCount: next.size })
 
-        // A failed run leaves the database out of date, and what fixes the usual
-        // cause (a header still half-written when it first appeared) is an edit
-        // rather than another file appearing, so a failure is worth retrying on any
-        // change at all rather than waiting for the set to move again
+        // A failed run leaves the database out of date, and its usual cause (a
+        // half-written header) is fixed by an edit rather than by a new file, so a
+        // failure is worth retrying on any change
         if (!hasChanged && !this._hasFailed()) return
 
         // A build or plugin descriptor can move the solution too, which is left to
@@ -288,7 +287,11 @@ export class CompileDbService {
         if (unrealEngineRoot !== this._engineRootOverride) {
             this._engineRootOverride = unrealEngineRoot
             this._context = null
-            compileDbStore.set({ engineRoot: null, target: null, lastError: null })
+            compileDbStore.set({
+                engineRoot: null,
+                target: null,
+                lastError: null,
+            })
         }
 
         if (isCompileDbAutoRegenEnabled === this._isEnabled) return
diff --git a/src/main/lib/compileDb/watch.ts b/src/main/lib/compileDb/watch.ts
index 5b816a4..7b592fc 100644
--- a/src/main/lib/compileDb/watch.ts
+++ b/src/main/lib/compileDb/watch.ts
@@ -17,9 +17,9 @@ export async function watchSourceTrees(root: string, onChange: () => void): Prom
     for (const watchRoot of resolveWatchRoots(root)) {
         if (!(await pathExists(watchRoot))) continue
 
-        // A tree can still go away between that check and this call, and a watcher
-        // can die later on for the same reason, neither of which is worth taking
-        // the main process down over, the next project bind sets things up again
+        // A tree can go away between that check and this call, and a watcher can die
+        // later for the same reason, neither worth taking the main process down over
+        // since the next project bind sets things up again
         try {
             const watcher = watch(watchRoot, { recursive: true, persistent: false }, () => onChange())
 
diff --git a/src/main/lib/constants.ts b/src/main/lib/constants.ts
index 589ef91..8fd441b 100644
--- a/src/main/lib/constants.ts
+++ b/src/main/lib/constants.ts
@@ -53,6 +53,7 @@ const CONSTANTS = {
         shellsOpenExternal: "shells:open-external",
         shellsShowFolder: "shells:show-folder",
         shellsOpenTerminal: "shells:open-terminal",
+        shellsOpenEditor: "shells:open-editor",
         // Dialogs
         dialogsConfirm: "dialogs:confirm",
         dialogsMessage: "dialogs:message",
@@ -125,26 +126,104 @@ const CONSTANTS = {
         missingFolderMessage: "The folder no longer exists on disk.",
         openFolderFailureMessage: "The system could not open the folder in the file manager.",
         noTerminalMessage: "No terminal could be launched, none of the ones we know about are installed or on PATH.",
+        noEditorMessage:
+            "No code editor could be found, none of the ones we know about are installed, set the path to yours under File > Options > General.",
+        openEditorFailureMessage: "The code editor set in the options is not where it is expected to be.",
+
+        /**
+         * How macOS is asked to open a folder with a given application, the editors are
+         * application bundles there rather than executables of their own.
+         */
+        macOpen: {
+            command: "open",
+            appFlag: "-a",
+        },
 
         /**
          * The terminals tried in order when opening a folder.
          */
         terminals: {
             win32: [
-                { command: "wt.exe", args: ["-d"], appendDir: true },
-                { command: "cmd.exe", args: ["/c", "start", "", "cmd.exe"], appendDir: false },
+                {
+                    command: "wt.exe",
+                    args: ["-d"],
+                    appendDir: true,
+                },
+                {
+                    command: "cmd.exe",
+                    args: ["/c", "start", "", "cmd.exe"],
+                    appendDir: false,
+                },
+            ],
+            darwin: [
+                {
+                    command: "open",
+                    args: ["-a", "Terminal"],
+                    appendDir: true,
+                },
             ],
-            darwin: [{ command: "open", args: ["-a", "Terminal"], appendDir: true }],
             linux: [
-                { command: "x-terminal-emulator", args: [], appendDir: false },
-                { command: "gnome-terminal", args: [], appendDir: false },
-                { command: "konsole", args: [], appendDir: false },
-                { command: "xfce4-terminal", args: [], appendDir: false },
-                { command: "alacritty", args: [], appendDir: false },
-                { command: "kitty", args: [], appendDir: false },
-                { command: "xterm", args: [], appendDir: false },
+                {
+                    command: "x-terminal-emulator",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "gnome-terminal",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "konsole",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "xfce4-terminal",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "alacritty",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "kitty",
+                    args: [],
+                    appendDir: false,
+                },
+                {
+                    command: "xterm",
+                    args: [],
+                    appendDir: false,
+                },
             ],
         } as Record<string, { command: string; args: string[]; appendDir: boolean }[]>,
+
+        /**
+         * The code editors tried in order when opening a project folder.
+         */
+        editors: {
+            win32: [
+                "%LOCALAPPDATA%\\Programs\\Microsoft VS Code\\Code.exe",
+                "%ProgramFiles%\\Microsoft VS Code\\Code.exe",
+                "%LOCALAPPDATA%\\Programs\\cursor\\Cursor.exe",
+                "%LOCALAPPDATA%\\Programs\\Microsoft VS Code Insiders\\Code - Insiders.exe",
+                "%LOCALAPPDATA%\\Programs\\Windsurf\\Windsurf.exe",
+                "%LOCALAPPDATA%\\Programs\\Rider\\bin\\rider64.exe",
+                "%ProgramFiles%\\Sublime Text\\sublime_text.exe",
+            ],
+            darwin: [
+                "/Applications/Visual Studio Code.app",
+                "/Applications/Cursor.app",
+                "/Applications/Visual Studio Code - Insiders.app",
+                "/Applications/Windsurf.app",
+                "/Applications/Rider.app",
+                "/Applications/Sublime Text.app",
+            ],
+            linux: ["code", "cursor", "code-insiders", "windsurf", "rider", "subl", "zed"],
+        } as Record<string, string[]>,
     },
     git: {
         logFieldSeparator: "\x1f",
@@ -158,7 +237,7 @@ const CONSTANTS = {
         contentDir: "Content",
         assetExtension: ".uasset",
         levelExtension: ".umap",
-        // The Unreal MCP exposes editor tools through a `call_tool` dispatcher rather
+        // The Unreal MCP exposes editor tools through a "call_tool" dispatcher rather
         // than as first-class MCP tools, so each entry pairs the toolset owning it with
         // its short name
         dispatcher: "call_tool",
diff --git a/src/main/lib/dialogs/index.ts b/src/main/lib/dialogs/index.ts
index a2403e9..4a8718c 100644
--- a/src/main/lib/dialogs/index.ts
+++ b/src/main/lib/dialogs/index.ts
@@ -61,7 +61,7 @@ class DialogRegistry {
     }
 
     /**
-     * Drops the entry for a closed window, cancelling any still-pending
+     * Drops the entry for a closed window, canceling any still-pending
      * awaiter, called from the window's `closed` handler.
      * @param id The window id.
      */
@@ -137,7 +137,7 @@ export function createDialogWindow(
  * (a close counts as a cancel).
  * @param parent The window that owns the dialog, or `null` to show it detached.
  * @param options The dialog contents and variant.
- * @returns `true` when confirmed, `false` when cancelled or closed.
+ * @returns `true` when confirmed, `false` when canceled or closed.
  */
 export function openDialog(parent: BrowserWindow | null, options: DialogOptions): Promise<boolean> {
     return new Promise(resolve => {
@@ -155,11 +155,19 @@ export function registerDialogsHandlers() {
     )
 
     ipcMain.on(CONSTANTS.ipc.dialogsMessage, (event, title: string, message: string) => {
-        openDialog(BrowserWindow.fromWebContents(event.sender), { variant: "message", title, message })
+        openDialog(BrowserWindow.fromWebContents(event.sender), {
+            variant: "message",
+            title,
+            message,
+        })
     })
 
     ipcMain.on(CONSTANTS.ipc.dialogsError, (event, title: string, message: string) => {
-        openDialog(BrowserWindow.fromWebContents(event.sender), { variant: "error", title, message })
+        openDialog(BrowserWindow.fromWebContents(event.sender), {
+            variant: "error",
+            title,
+            message,
+        })
     })
 
     ipcMain.on(CONSTANTS.ipc.dialogsErrorWithDetails, (event, title: string, message: string, details: string) => {
diff --git a/src/main/lib/gitCommands/exec.ts b/src/main/lib/gitCommands/exec.ts
index fb3f229..5a6b11e 100644
--- a/src/main/lib/gitCommands/exec.ts
+++ b/src/main/lib/gitCommands/exec.ts
@@ -47,7 +47,7 @@ export async function runGit(args: string[], options: RunGitOptions): Promise<Gi
             signal?: NodeJS.Signals | null
         }
 
-        // A missing `git` binary surfaces as a spawn error with a string code (e.g "ENOENT")
+        // A missing "git" binary surfaces as a spawn error with a string code (e.g "ENOENT")
         if (typeof typedError.code === "string") {
             throw new Error(`Failed to run git (${typedError.code}). Is git installed and on your PATH?`)
         }
diff --git a/src/main/lib/gitCommands/parse.ts b/src/main/lib/gitCommands/parse.ts
index f3aabdb..541557d 100644
--- a/src/main/lib/gitCommands/parse.ts
+++ b/src/main/lib/gitCommands/parse.ts
@@ -136,6 +136,7 @@ export function parseStatus(output: string): GitStatus {
     }
 
     status.isClean = status.changes.length === 0
+
     return status
 }
 
diff --git a/src/main/lib/lfsCommands/handlers.ts b/src/main/lib/lfsCommands/handlers.ts
index 5a5f842..398e179 100644
--- a/src/main/lib/lfsCommands/handlers.ts
+++ b/src/main/lib/lfsCommands/handlers.ts
@@ -29,7 +29,11 @@ export function registerLfsCommandsHandlers() {
     safeHandle(CONSTANTS.ipc.lfsCommandsLockPaths, (event, dir: string, paths: string[], requestId: string | null) =>
         lockPaths(dir, paths, (done, total) => {
             if (!requestId || event.sender.isDestroyed()) return
-            const payload: LfsLockProgress = { requestId, done, total }
+            const payload: LfsLockProgress = {
+                requestId,
+                done,
+                total,
+            }
             event.sender.send(CONSTANTS.ipc.lfsCommandsLockProgress, payload)
         }),
     )
@@ -39,7 +43,11 @@ export function registerLfsCommandsHandlers() {
         (event, dir: string, paths: string[], force: boolean | undefined, requestId: string | null) =>
             unlockPaths(dir, paths, force, (done, total) => {
                 if (!requestId || event.sender.isDestroyed()) return
-                const payload: LfsLockProgress = { requestId, done, total }
+                const payload: LfsLockProgress = {
+                    requestId,
+                    done,
+                    total,
+                }
                 event.sender.send(CONSTANTS.ipc.lfsCommandsLockProgress, payload)
             }),
     )
diff --git a/src/main/lib/lfsCommands/service.ts b/src/main/lib/lfsCommands/service.ts
index e712c75..00c0fb7 100644
--- a/src/main/lib/lfsCommands/service.ts
+++ b/src/main/lib/lfsCommands/service.ts
@@ -150,6 +150,7 @@ export async function lockPaths(
         const result = await runLockCommand(dir, ["lfs", "lock", file], file)
         done += 1
         onProgress?.(done, files.length)
+
         return result
     })
 }
@@ -181,6 +182,7 @@ export async function unlockPaths(
         const result = await runLockCommand(dir, args, file)
         done += 1
         onProgress?.(done, files.length)
+
         return result
     })
 }
diff --git a/src/main/lib/mcp/client.ts b/src/main/lib/mcp/client.ts
index a67b62c..8bccb29 100644
--- a/src/main/lib/mcp/client.ts
+++ b/src/main/lib/mcp/client.ts
@@ -12,6 +12,11 @@ import type { McpServerInfo } from "@/main/types/mcp"
 export class McpError extends Error {
     readonly code: number
 
+    /**
+     * Creates an error from what the MCP server reported.
+     * @param code The numeric JSON-RPC error code.
+     * @param message The human-readable message that came back.
+     */
     constructor(code: number, message: string) {
         super(message)
         this.name = "McpError"
diff --git a/src/main/lib/mcp/service.ts b/src/main/lib/mcp/service.ts
index 09c2403..7fe1462 100644
--- a/src/main/lib/mcp/service.ts
+++ b/src/main/lib/mcp/service.ts
@@ -128,7 +128,11 @@ export class McpService {
 
         if (hasEndpointChanged) {
             mcpClient.resetSession()
-            mcpStore.set({ status: "disconnected", server: null, error: null })
+            mcpStore.set({
+                status: "disconnected",
+                server: null,
+                error: null,
+            })
         }
 
         if (hasIntervalChanged && this._probeTimer) this._restartTimer()
diff --git a/src/main/lib/projects/service.ts b/src/main/lib/projects/service.ts
index d0a8b1c..f363ad9 100644
--- a/src/main/lib/projects/service.ts
+++ b/src/main/lib/projects/service.ts
@@ -93,7 +93,7 @@ export async function addLocalProject(window: BrowserWindow | null): Promise<Ope
     if (selection.canceled || selection.filePaths.length === 0) {
         return {
             ok: false,
-            reason: "cancelled",
+            reason: "canceled",
         }
     }
 
diff --git a/src/main/lib/shells/editors.ts b/src/main/lib/shells/editors.ts
new file mode 100644
index 0000000..c7eabfe
--- /dev/null
+++ b/src/main/lib/shells/editors.ts
@@ -0,0 +1,81 @@
+import path from "node:path"
+import CONSTANTS from "@main/lib/constants"
+import { pathExists } from "@main/lib/utils/fs"
+
+/**
+ * How a code editor is launched on a folder, ready to be handed to `spawn`.
+ */
+export type EditorLaunch = {
+    command: string
+    args: string[]
+}
+
+/**
+ * Expands the `%VAR%` placeholders of a candidate from the environment, an editor's
+ * install directory is only ever known relative to one of them.
+ * @param candidate The raw candidate, which may hold placeholders.
+ * @returns The expanded candidate, or `null` when one of the variables is unset, which
+ * rules the candidate out rather than leaving a hole in its path.
+ */
+export function expandEnvPlaceholders(candidate: string): string | null {
+    let isResolved = true
+
+    const expanded = candidate.replace(/%([^%]+)%/g, (_match, name: string) => {
+        const value = process.env[name]
+        if (!value) isResolved = false
+
+        return value ?? ""
+    })
+
+    return isResolved ? expanded : null
+}
+
+/**
+ * Builds the command and arguments opening a folder with a given editor, macOS goes
+ * through `open` because an editor is an application bundle there rather than an
+ * executable that can be spawned on its own.
+ * @param target The resolved editor, an executable elsewhere and a bundle on macOS.
+ * @param dir The absolute path of the folder to open.
+ * @returns The command and its arguments.
+ */
+function buildEditorLaunch(target: string, dir: string): EditorLaunch {
+    if (process.platform === "darwin") {
+        return {
+            command: CONSTANTS.shells.macOpen.command,
+            args: [CONSTANTS.shells.macOpen.appFlag, target, dir],
+        }
+    }
+
+    return {
+        command: target,
+        args: [dir],
+    }
+}
+
+/**
+ * Turns an editor candidate into the launch opening a folder with it.
+ *
+ * Note: an absolute candidate is checked on disk first, macOS reports a missing app
+ * through `open`'s exit code rather than through a spawn failure.
+ * @param candidate The candidate, an absolute path with optional `%VAR%` placeholders or
+ * a bare command name looked up on `PATH`.
+ * @param dir The absolute path of the folder to open.
+ * @returns The launch to spawn, or `null` when the candidate is unavailable.
+ */
+export async function resolveEditorLaunch(candidate: string, dir: string): Promise<EditorLaunch | null> {
+    const target = expandEnvPlaceholders(candidate)
+    if (!target) return null
+
+    if (path.isAbsolute(target) && !(await pathExists(target))) return null
+
+    return buildEditorLaunch(target, dir)
+}
+
+/**
+ * Lists the editor candidates to try for the current platform, falling back to the Linux
+ * ones on a platform we hold no list for.
+ * @returns The candidates, in the order they are worth trying.
+ */
+export function listEditorCandidates(): string[] {
+    return CONSTANTS.shells.editors[process.platform] ?? CONSTANTS.shells.editors.linux
+}
diff --git a/src/main/lib/shells/handlers.ts b/src/main/lib/shells/handlers.ts
index 42d4dfd..a46b08f 100644
--- a/src/main/lib/shells/handlers.ts
+++ b/src/main/lib/shells/handlers.ts
@@ -1,6 +1,6 @@
 import CONSTANTS from "@main/lib/constants"
 import { safeHandle } from "@main/lib/ipc"
-import { openTerminal, showFolder } from "@main/lib/shells/service"
+import { openEditor, openTerminal, showFolder } from "@main/lib/shells/service"
 import { ipcMain, shell } from "electron"
 
 /**
@@ -13,12 +13,13 @@ const ALLOWED_PROTOCOLS = new Set(["http:", "https:"])
 
 /**
  * Registers the IPC handlers that open an external URL in the user's default browser
- * (ignoring any URL that is malformed or uses a disallowed protocol) and that reveal a
- * folder in the OS file manager.
+ * (ignoring any URL that is malformed or uses a disallowed protocol) and that hand a
+ * folder to the OS file manager, to a terminal or to a code editor.
  */
 export function registerShellsHandlers() {
     safeHandle(CONSTANTS.ipc.shellsShowFolder, (_event, dir: string) => showFolder(dir))
     safeHandle(CONSTANTS.ipc.shellsOpenTerminal, (_event, dir: string) => openTerminal(dir))
+    safeHandle(CONSTANTS.ipc.shellsOpenEditor, (_event, dir: string) => openEditor(dir))
 
     ipcMain.on(CONSTANTS.ipc.shellsOpenExternal, (_event, url: string) => {
         let parsed: URL
diff --git a/src/main/lib/shells/service.ts b/src/main/lib/shells/service.ts
index 1e567f4..59d79c8 100644
--- a/src/main/lib/shells/service.ts
+++ b/src/main/lib/shells/service.ts
@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process"
 import { stat } from "node:fs/promises"
 import CONSTANTS from "@main/lib/constants"
+import { listEditorCandidates, resolveEditorLaunch } from "@main/lib/shells/editors"
+import { preferencesStore } from "@main/lib/stores/preferences"
 import { shell } from "electron"
 
 /**
@@ -24,7 +26,11 @@ async function assertDirectory(dir: string): Promise<void> {
  */
 function trySpawn(command: string, args: string[], cwd: string): Promise<boolean> {
     return new Promise(resolve => {
-        const child = spawn(command, args, { cwd, detached: true, stdio: "ignore" })
+        const child = spawn(command, args, {
+            cwd,
+            detached: true,
+            stdio: "ignore",
+        })
 
         child.once("spawn", () => {
             // Lets the terminal outlive the app rather than dying alongside it
@@ -67,3 +73,33 @@ export async function openTerminal(dir: string): Promise<void> {
 
     throw new Error(CONSTANTS.shells.noTerminalMessage)
 }
+
+/**
+ * Open a folder in a code editor, the one set in the preferences when there is one, and
+ * otherwise the first of the editors we know about that turns out to be installed.
+ * @param dir Absolute path to the folder to open.
+ * @throws When the path is not a directory, when the editor set in the preferences could
+ * not be launched, or when no editor could be found at all.
+ */
+export async function openEditor(dir: string): Promise<void> {
+    await assertDirectory(dir)
+
+    const { codeEditorPath } = preferencesStore.get()
+    const preferred = codeEditorPath.trim()
+
+    // A hand-picked editor is never fallen back on, silently opening another one would
+    // read as the setting being ignored
+    if (preferred) {
+        const launch = await resolveEditorLaunch(preferred, dir)
+        if (launch && (await trySpawn(launch.command, launch.args, dir))) return
+
+        throw new Error(`${CONSTANTS.shells.openEditorFailureMessage}\n\n${preferred}`)
+    }
+
+    for (const candidate of listEditorCandidates()) {
+        const launch = await resolveEditorLaunch(candidate, dir)
+        if (launch && (await trySpawn(launch.command, launch.args, dir))) return
+    }
+
+    throw new Error(CONSTANTS.shells.noEditorMessage)
+}
diff --git a/src/main/lib/stores/config.ts b/src/main/lib/stores/config.ts
index 1ad7b81..d579ebb 100644
--- a/src/main/lib/stores/config.ts
+++ b/src/main/lib/stores/config.ts
@@ -17,6 +17,7 @@ function normalizeConfig(partial: Partial<AppConfig>): AppConfig {
         preferences: {
             theme: preferences.theme ?? DEFAULT_APP_CONFIG.preferences.theme,
             startupBehavior: preferences.startupBehavior ?? DEFAULT_APP_CONFIG.preferences.startupBehavior,
+            codeEditorPath: preferences.codeEditorPath ?? DEFAULT_APP_CONFIG.preferences.codeEditorPath,
             autoLockTickIntervalMs:
                 preferences.autoLockTickIntervalMs ?? DEFAULT_APP_CONFIG.preferences.autoLockTickIntervalMs,
             mcpEndpoint: preferences.mcpEndpoint ?? DEFAULT_APP_CONFIG.preferences.mcpEndpoint,
diff --git a/src/main/lib/stores/json.ts b/src/main/lib/stores/json.ts
index 44f0ed0..80ac61c 100644
--- a/src/main/lib/stores/json.ts
+++ b/src/main/lib/stores/json.ts
@@ -38,6 +38,10 @@ export class JsonStore<T extends object> {
      */
     private _writeCounter = 0
 
+    /**
+     * Creates the store, nothing reaches disk until the first read or write.
+     * @param options The file name, defaults and normalizer to own the file with.
+     */
     constructor(options: JsonStoreOptions<T>) {
         this._options = options
     }
@@ -113,6 +117,7 @@ export class JsonStore<T extends object> {
             await this._save(result)
 
             this._cache = result
+
             return result
         })
 
diff --git a/src/main/lib/stores/observable.ts b/src/main/lib/stores/observable.ts
index ccd8fc0..7406b05 100644
--- a/src/main/lib/stores/observable.ts
+++ b/src/main/lib/stores/observable.ts
@@ -14,6 +14,11 @@ export class ObservableStore<T extends object> {
      */
     private _listeners = new Set<(next: T) => void>()
 
+    /**
+     * Creates the store around a starting state, no listener runs until the
+     * first transition.
+     * @param initialState The state the store starts from.
+     */
     constructor(initialState: T) {
         this._state = initialState
     }
diff --git a/src/main/lib/updater/service.ts b/src/main/lib/updater/service.ts
index 292778d..b5c160f 100644
--- a/src/main/lib/updater/service.ts
+++ b/src/main/lib/updater/service.ts
@@ -105,7 +105,7 @@ export async function checkForUpdates(isManualCheck = false) {
     try {
         await autoUpdater.checkForUpdates()
     } catch {
-        // Swallowed on purpose: electron-updater emits `error` before rethrowing, so
+        // Swallowed on purpose: electron-updater emits "error" before rethrowing, so
         // the listener has already recorded it and reacting here would broadcast twice
     }
 }
@@ -136,7 +136,7 @@ export async function downloadUpdate() {
     try {
         await autoUpdater.downloadUpdate()
     } catch {
-        // Swallowed for the same reason as in `checkForUpdates`, the `error` listener owns it
+        // Swallowed for the same reason as in "checkForUpdates", the "error" listener owns it
     }
 }
 
diff --git a/src/main/lib/updater/store.ts b/src/main/lib/updater/store.ts
index 9cc8acf..d677cf8 100644
--- a/src/main/lib/updater/store.ts
+++ b/src/main/lib/updater/store.ts
@@ -43,6 +43,9 @@ export class UpdaterStore extends ObservableStore<UpdaterState> {
      */
     private _dismissedVersion: string | null = null
 
+    /**
+     * Creates the store on a fresh idle state, with nothing dismissed yet.
+     */
     constructor() {
         super(createInitialState())
     }
diff --git a/src/main/lib/utils/async.ts b/src/main/lib/utils/async.ts
index 4f644c7..ef92828 100644
--- a/src/main/lib/utils/async.ts
+++ b/src/main/lib/utils/async.ts
@@ -16,7 +16,6 @@ export async function parallelLimit<T, R>(
 
     /**
      * Runs the worker on the next item in the queue.
-     * @returns A promise that resolves when the worker is done.
      */
     const run = async (): Promise<void> => {
         while (cursor < items.length) {
diff --git a/src/main/types/lfsCommands.d.ts b/src/main/types/lfsCommands.d.ts
index d6eb8bc..739d0b6 100644
--- a/src/main/types/lfsCommands.d.ts
+++ b/src/main/types/lfsCommands.d.ts
@@ -33,8 +33,16 @@ export type LfsLockProgress = {
  * the old path's lock was carried over to the new path.
  */
 export type LfsLockMigration = {
+    /**
+     * The staged rename's old path, whose lock is the one being carried over.
+     */
     from: string
+
+    /**
+     * The staged rename's new path, the one the lock is carried to.
+     */
     to: string
+
     /**
      * The migration status, `migrated` on success, `skipped-*` when the migration
      * did not apply, `failed-*` when a step errored, self-describing suffixes.
@@ -46,5 +54,9 @@ export type LfsLockMigration = {
         | "skipped-not-lockable"
         | "failed-lock"
         | "failed-unlock"
+
+    /**
+     * What went wrong, set only alongside a `failed-*` status.
+     */
     error?: string
 }
diff --git a/src/main/types/projects.d.ts b/src/main/types/projects.d.ts
index 100ff21..ede0622 100644
--- a/src/main/types/projects.d.ts
+++ b/src/main/types/projects.d.ts
@@ -11,11 +11,11 @@ export type Project = {
 }
 
 /**
- * Why opening a project did not result in an open repository, `cancelled` when
+ * Why opening a project did not result in an open repository, `canceled` when
  * the picker was dismissed, `not-found`, `not-a-repository`, and `not-a-ue-project`
  * cover the disk, git, and UE root-file checks respectively.
  */
-export type OpenProjectFailureReason = "cancelled" | "not-found" | "not-a-repository" | "not-a-ue-project"
+export type OpenProjectFailureReason = "canceled" | "not-found" | "not-a-repository" | "not-a-ue-project"
 
 /**
  * The outcome of attempting to open or add a project.
diff --git a/src/main/types/store.d.ts b/src/main/types/store.d.ts
index f152ffd..3f52471 100644
--- a/src/main/types/store.d.ts
+++ b/src/main/types/store.d.ts
@@ -12,6 +12,7 @@ export type StartupBehavior = "reopen-last" | "start-clean"
 export type AppPreferences = {
     theme: string
     startupBehavior: StartupBehavior
+    codeEditorPath: string
     autoLockTickIntervalMs: number
     mcpEndpoint: string
     mcpProbeIntervalMs: number
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 876f6a9..cc87fae 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -133,6 +133,7 @@ export type GitgameApi = {
         openExternal: (url: string) => void
         showFolder: (dir: string) => Promise<void>
         openTerminal: (dir: string) => Promise<void>
+        openEditor: (dir: string) => Promise<void>
     }
     updater: {
         getState: () => Promise<UpdaterState>
diff --git a/src/preload/lib/lockProgress.ts b/src/preload/lib/lockProgress.ts
index a52fa68..d9121e2 100644
--- a/src/preload/lib/lockProgress.ts
+++ b/src/preload/lib/lockProgress.ts
@@ -17,6 +17,12 @@ export async function withLockProgress<T>(
     if (!onProgress) return invoke(null)
 
     const requestId = randomUUID()
+    /**
+     * Reports a progress tick, ignoring the ticks belonging to another caller's
+     * in-flight request.
+     * @param _ The Electron event, unused.
+     * @param payload The progress tick the main process broadcast.
+     */
     const listener = (_: unknown, payload: LfsLockProgress) => {
         if (payload.requestId === requestId) onProgress(payload.done, payload.total)
     }
diff --git a/src/preload/routes/autoLock.ts b/src/preload/routes/autoLock.ts
index 6885ea1..a9fa7da 100644
--- a/src/preload/routes/autoLock.ts
+++ b/src/preload/routes/autoLock.ts
@@ -9,7 +9,14 @@ const autoLockApiRoutes: GitgameApi["autoLock"] = {
     reconcile: (dir: string) => safeInvoke(CONSTANTS.ipc.autoLockReconcile, dir),
     getState: () => safeInvoke(CONSTANTS.ipc.autoLockGetState),
     onStateChange: callback => {
-        const listener = (_: unknown, state: AutoLockState) => callback(state)
+        /**
+         * Forwards a broadcast auto-lock state to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param state The auto-lock state the main process broadcast.
+         */
+        const listener = (_: unknown, state: AutoLockState) => {
+            callback(state)
+        }
         ipcRenderer.on(CONSTANTS.ipc.autoLockStateChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.autoLockStateChanged, listener)
     },
diff --git a/src/preload/routes/compileDb.ts b/src/preload/routes/compileDb.ts
index ab525f9..974615d 100644
--- a/src/preload/routes/compileDb.ts
+++ b/src/preload/routes/compileDb.ts
@@ -7,7 +7,14 @@ import type { CompileDbState } from "@/main/types/compileDb"
 const compileDbApiRoutes: GitgameApi["compileDb"] = {
     getState: () => safeInvoke(CONSTANTS.ipc.compileDbGetState),
     onStateChange: callback => {
-        const listener = (_: unknown, state: CompileDbState) => callback(state)
+        /**
+         * Forwards a broadcast compile database state to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param state The compile database state the main process broadcast.
+         */
+        const listener = (_: unknown, state: CompileDbState) => {
+            callback(state)
+        }
         ipcRenderer.on(CONSTANTS.ipc.compileDbStateChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.compileDbStateChanged, listener)
     },
diff --git a/src/preload/routes/mcp.ts b/src/preload/routes/mcp.ts
index 22131be..830a8e6 100644
--- a/src/preload/routes/mcp.ts
+++ b/src/preload/routes/mcp.ts
@@ -7,7 +7,14 @@ import type { McpState } from "@/main/types/mcp"
 const mcpApiRoutes: GitgameApi["mcp"] = {
     getState: () => safeInvoke(CONSTANTS.ipc.mcpGetState),
     onStateChange: callback => {
-        const listener = (_: unknown, state: McpState) => callback(state)
+        /**
+         * Forwards a broadcast MCP state to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param state The MCP state the main process broadcast.
+         */
+        const listener = (_: unknown, state: McpState) => {
+            callback(state)
+        }
         ipcRenderer.on(CONSTANTS.ipc.mcpStateChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.mcpStateChanged, listener)
     },
diff --git a/src/preload/routes/preferences.ts b/src/preload/routes/preferences.ts
index f7a44d3..8f7403d 100644
--- a/src/preload/routes/preferences.ts
+++ b/src/preload/routes/preferences.ts
@@ -9,7 +9,14 @@ const preferencesApiRoutes: GitgameApi["preferences"] = {
     get: () => safeInvoke<AppPreferences>(CONSTANTS.ipc.preferencesGet),
     set: patch => safeInvoke<AppPreferences>(CONSTANTS.ipc.preferencesSet, patch),
     onChange: callback => {
-        const listener = (_: unknown, next: AppPreferences) => callback(next)
+        /**
+         * Forwards the committed preferences to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param next The preferences the main process broadcast.
+         */
+        const listener = (_: unknown, next: AppPreferences) => {
+            callback(next)
+        }
         ipcRenderer.on(CONSTANTS.ipc.preferencesChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.preferencesChanged, listener)
     },
diff --git a/src/preload/routes/shells.ts b/src/preload/routes/shells.ts
index f67c8a0..3e2e823 100644
--- a/src/preload/routes/shells.ts
+++ b/src/preload/routes/shells.ts
@@ -7,6 +7,7 @@ const shellsApiRoutes: GitgameApi["shells"] = {
     openExternal: url => ipcRenderer.send(CONSTANTS.ipc.shellsOpenExternal, url),
     showFolder: dir => safeInvoke<void>(CONSTANTS.ipc.shellsShowFolder, dir),
     openTerminal: dir => safeInvoke<void>(CONSTANTS.ipc.shellsOpenTerminal, dir),
+    openEditor: dir => safeInvoke<void>(CONSTANTS.ipc.shellsOpenEditor, dir),
 }
 
 export default shellsApiRoutes
diff --git a/src/preload/routes/updater.ts b/src/preload/routes/updater.ts
index 1ec283f..f091aac 100644
--- a/src/preload/routes/updater.ts
+++ b/src/preload/routes/updater.ts
@@ -7,7 +7,14 @@ import type { UpdaterState } from "@/main/types/updater"
 const updaterApiRoutes: GitgameApi["updater"] = {
     getState: () => safeInvoke(CONSTANTS.ipc.updaterGetState),
     onStateChange: callback => {
-        const listener = (_: unknown, state: UpdaterState) => callback(state)
+        /**
+         * Forwards a broadcast updater state to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param state The updater state the main process broadcast.
+         */
+        const listener = (_: unknown, state: UpdaterState) => {
+            callback(state)
+        }
         ipcRenderer.on(CONSTANTS.ipc.updaterStateChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.updaterStateChanged, listener)
     },
diff --git a/src/preload/routes/windows.ts b/src/preload/routes/windows.ts
index 2a472c5..45e7809 100644
--- a/src/preload/routes/windows.ts
+++ b/src/preload/routes/windows.ts
@@ -5,7 +5,14 @@ import { ipcRenderer } from "electron"
 const windowsApiRoutes: GitgameApi["windows"] = {
     getState: () => ipcRenderer.invoke(CONSTANTS.ipc.windowsGetState),
     onStateChange: callback => {
-        const listener = (_: unknown, state: WindowState) => callback(state)
+        /**
+         * Forwards a broadcast window state to the subscriber.
+         * @param _ The Electron event, unused.
+         * @param state The window state the main process broadcast.
+         */
+        const listener = (_: unknown, state: WindowState) => {
+            callback(state)
+        }
         ipcRenderer.on(CONSTANTS.ipc.windowsStateChanged, listener)
         return () => ipcRenderer.off(CONSTANTS.ipc.windowsStateChanged, listener)
     },
diff --git a/src/renderer/components/contexts/Project.tsx b/src/renderer/components/contexts/Project.tsx
index b129749..0d5cf19 100644
--- a/src/renderer/components/contexts/Project.tsx
+++ b/src/renderer/components/contexts/Project.tsx
@@ -36,6 +36,7 @@ type ProjectProviderProps = {
 /**
  * Provides the current project and recent projects to the component tree, backed
  * by the `window.api.projects` bridge.
+ * @param children The tree that reads the project context.
  */
 export default function ProjectProvider({ children }: ProjectProviderProps) {
     const [currentProject, setCurrentProject] = useState<Project | null>(null)
@@ -63,7 +64,7 @@ export default function ProjectProvider({ children }: ProjectProviderProps) {
 
                 if (result.ok) {
                     setCurrentProject(result.project)
-                } else if (result.reason !== "cancelled") {
+                } else if (result.reason !== "canceled") {
                     const message =
                         CONSTANTS.PROJECT_OPEN_FAILURE_MESSAGES[result.reason] ?? "The project couldn't be opened."
                     window.api.dialogs.errorWithDetails(
@@ -74,8 +75,8 @@ export default function ProjectProvider({ children }: ProjectProviderProps) {
                 }
 
                 await refreshRecentProjects()
-            } catch (err) {
-                const details = err instanceof Error ? err.message : String(err)
+            } catch (error) {
+                const details = error instanceof Error ? error.message : String(error)
                 window.api.dialogs.errorWithDetails(
                     "Can't open project",
                     "An unexpected error occurred while opening the project.",
@@ -167,27 +168,31 @@ export default function ProjectProvider({ children }: ProjectProviderProps) {
             return
         }
 
-        let cancelled = false
+        let canceled = false
 
         window.api.gitCommands
             .getRemoteUrl(currentProject.path)
             .then(url => {
-                if (cancelled) return
+                if (canceled) return
                 setRemoteUrl(url)
             })
             .catch(() => {
-                if (cancelled) return
+                if (canceled) return
                 setRemoteUrl(null)
             })
 
         return () => {
-            cancelled = true
+            canceled = true
         }
     }, [currentProject?.path])
 
     // On mount, load the recent projects and, when configured to do so, re-open
     // the most recently opened project
     useEffect(() => {
+        /**
+         * Loads the recent projects and, when the preference asks for it, reopens
+         * the most recent one.
+         */
         const init = async () => {
             setIsLoading(true)
 
@@ -199,8 +204,8 @@ export default function ProjectProvider({ children }: ProjectProviderProps) {
                 if (window.api.preferences.initial.startupBehavior === "reopen-last" && projects[0]) {
                     await openProject(projects[0].path)
                 }
-            } catch (err) {
-                const details = err instanceof Error ? err.message : String(err)
+            } catch (error) {
+                const details = error instanceof Error ? error.message : String(error)
                 window.api.dialogs.errorWithDetails(
                     "Failed to load recent projects",
                     "The recent projects list couldn't be loaded on startup.",
diff --git a/src/renderer/components/contexts/Status.tsx b/src/renderer/components/contexts/Status.tsx
index 2a48f5b..bab3fa6 100644
--- a/src/renderer/components/contexts/Status.tsx
+++ b/src/renderer/components/contexts/Status.tsx
@@ -44,6 +44,7 @@ type StatusProviderProps = {
 /**
  * Provides the status task stack to the component tree, backed by an in-memory
  * store.
+ * @param children The tree that reads the status context.
  */
 export default function StatusProvider({ children }: StatusProviderProps) {
     const [tasks, setTasks] = useState<StatusTask[]>([])
@@ -62,7 +63,14 @@ export default function StatusProvider({ children }: StatusProviderProps) {
         nextId.current += 1
         const id = `task-${nextId.current}`
 
-        setTasks(previous => [...previous, { id, label, progress: null }])
+        setTasks(previous => [
+            ...previous,
+            {
+                id,
+                label,
+                progress: null,
+            },
+        ])
 
         return {
             setLabel: nextLabel =>
@@ -112,6 +120,10 @@ export default function StatusProvider({ children }: StatusProviderProps) {
         [startTask],
     )
 
+    /**
+     * The value handed to consumers, memoized so a provider re-render that leaves
+     * the tasks and their helpers untouched does not invalidate every consumer.
+     */
     const value = useMemo<StatusContextType>(
         () => ({
             tasks,
diff --git a/src/renderer/components/contexts/TreeView.tsx b/src/renderer/components/contexts/TreeView.tsx
index 7b0abd3..b1e28e6 100644
--- a/src/renderer/components/contexts/TreeView.tsx
+++ b/src/renderer/components/contexts/TreeView.tsx
@@ -135,15 +135,16 @@ export default function TreeViewProvider({ children }: TreeViewProviderProps) {
     // Hydrate the persisted search view state once on mount, so the search
     // scope survives across sessions
     useEffect(() => {
-        let cancelled = false
+        let canceled = false
 
         window.api.viewState
             .get()
             .then(view => {
-                if (cancelled) return
+                if (canceled) return
 
                 setIsRegex(view.searchIsRegex)
                 setIsAdvancedOpen(view.isAdvancedSearchOpened)
+
                 setIncludeText(view.searchIncludePatterns)
                 setExcludeText(view.searchExcludePatterns)
                 setIsShowingMyLocksOnly(view.isShowingMyLocksOnly)
@@ -153,7 +154,7 @@ export default function TreeViewProvider({ children }: TreeViewProviderProps) {
             })
 
         return () => {
-            cancelled = true
+            canceled = true
         }
     }, [])
 
@@ -179,7 +180,11 @@ export default function TreeViewProvider({ children }: TreeViewProviderProps) {
         [debouncedQuery, isRegex, debouncedInclude, debouncedExclude],
     )
 
-    const isSearching = filters.query.trim().length > 0
+    /**
+     * Whether a query is currently narrowing the tree, it keys off the debounced
+     * value so a keystroke still in flight does not flip the tree.
+     */
+    const isSearching = useMemo(() => filters.query.trim().length > 0, [filters.query])
 
     /**
      * The tree the user actually sees, optionally pruned to files locked by the
@@ -387,6 +392,10 @@ export default function TreeViewProvider({ children }: TreeViewProviderProps) {
         reveal(menu.node.path)
     }, [menu, dismissMenu, reveal])
 
+    /**
+     * The value handed to consumers, memoized so a provider re-render that leaves
+     * the selection and the visible tree untouched does not invalidate every consumer.
+     */
     const value = useMemo<TreeViewContextType>(
         () => ({
             expandedPaths,
diff --git a/src/renderer/components/fields/StatusCompileDb.tsx b/src/renderer/components/fields/StatusCompileDb.tsx
index 3a0b3b3..c4ea3f4 100644
--- a/src/renderer/components/fields/StatusCompileDb.tsx
+++ b/src/renderer/components/fields/StatusCompileDb.tsx
@@ -23,7 +23,10 @@ export default function StatusCompileDbField({ className }: StatusCompileDbField
     /**
      * Whether the last regeneration failed.
      */
-    const hasFailed = Boolean(state?.lastError || state?.lastResult?.ok === false)
+    const hasFailed = useMemo(
+        () => Boolean(state?.lastError || state?.lastResult?.ok === false),
+        [state?.lastError, state?.lastResult?.ok],
+    )
 
     /**
      * The chip label built from the current watcher state, `null` while the first
diff --git a/src/renderer/components/fields/StatusUpdate.tsx b/src/renderer/components/fields/StatusUpdate.tsx
index 5bfa676..5d51b81 100644
--- a/src/renderer/components/fields/StatusUpdate.tsx
+++ b/src/renderer/components/fields/StatusUpdate.tsx
@@ -1,7 +1,7 @@
 import downloadIcon from "@react95-icons/Download_16x16_4.png"
 import useUpdaterState from "@renderer/hooks/useUpdaterState"
 import { buildUpdaterStatusLabel } from "@renderer/lib/utils/updater"
-import { useCallback, useMemo } from "react"
+import { type MouseEvent, useCallback, useMemo } from "react"
 import { Button } from "react95"
 import StatusBarFrame from "@/renderer/components/frames/StatusBar"
 import TileProgressBar from "@/renderer/components/ui/TileProgressBar"
@@ -19,29 +19,49 @@ export default function StatusUpdateField() {
      * The download progress as a rounded percentage, `0` before the first
      * `download-progress` event lands so the bar starts empty.
      */
-    const downloadPercentage = Math.round(state?.progress?.percent ?? 0)
+    const downloadPercentage = useMemo(() => Math.round(state?.progress?.percent ?? 0), [state?.progress?.percent])
+
+    /**
+     * Opens the update dialog, the chip only advertises the version and the dialog is
+     * where its release notes can be read before committing to the update.
+     */
+    const handleOpenDialog = useCallback(() => {
+        window.api.updater.openDialog()
+    }, [])
 
     /**
      * Runs the action that matches the current state.
+     * @param event The click event, kept from reaching the chip behind the button so the
+     * verb the user pressed is the one that runs.
      */
-    const handleAction = useCallback(() => {
-        if (state?.status === "downloaded") {
-            window.api.updater.install()
-            return
-        }
+    const handleAction = useCallback(
+        (event: MouseEvent<HTMLButtonElement>) => {
+            event.stopPropagation()
 
-        if (state?.canAutoInstall) {
-            window.api.updater.download()
-            return
-        }
+            if (state?.status === "downloaded") {
+                window.api.updater.install()
+                return
+            }
 
-        window.api.updater.openDialog()
-    }, [state?.canAutoInstall, state?.status])
+            if (state?.canAutoInstall) {
+                window.api.updater.download()
+                return
+            }
+
+            window.api.updater.openDialog()
+        },
+        [state?.canAutoInstall, state?.status],
+    )
 
     if (!state || !label) return null
 
     return (
-        <StatusBarFrame icon={downloadIcon} label={label} isLabelBold={state.status === "downloaded"}>
+        <StatusBarFrame
+            icon={downloadIcon}
+            label={label}
+            isLabelBold={state.status === "downloaded"}
+            onClick={handleOpenDialog}
+        >
             {state.status === "downloading" ? (
                 <TileProgressBar value={downloadPercentage} hideValue />
             ) : (
diff --git a/src/renderer/components/menus/TreeViewContextMenu.tsx b/src/renderer/components/menus/TreeViewContextMenu.tsx
index b7555da..0dd2861 100644
--- a/src/renderer/components/menus/TreeViewContextMenu.tsx
+++ b/src/renderer/components/menus/TreeViewContextMenu.tsx
@@ -13,7 +13,9 @@ export default function TreeViewContextMenu() {
         /**
          * Dismisses the menu on a pointer press anywhere in the document.
          */
-        const handlePointerDown = () => dismissMenu()
+        const handlePointerDown = () => {
+            dismissMenu()
+        }
 
         /**
          * Dismisses the menu when the escape key is pressed.
diff --git a/src/renderer/components/preferences/GeneralTab.tsx b/src/renderer/components/preferences/GeneralTab.tsx
index 30befe7..8b92d3d 100644
--- a/src/renderer/components/preferences/GeneralTab.tsx
+++ b/src/renderer/components/preferences/GeneralTab.tsx
@@ -1,4 +1,4 @@
-import { GroupBox, Radio } from "react95"
+import { GroupBox, Radio, TextInput } from "react95"
 import type { AppPreferences, StartupBehavior } from "@/main/types/store"
 
 type GeneralTabProps = {
@@ -28,6 +28,20 @@ export default function GeneralTab({ draft, onChange }: GeneralTabProps) {
                     />
                 </div>
             </GroupBox>
+
+            <GroupBox label="Code editor">
+                {/* biome-ignore lint/a11y/noLabelWithoutControl: React95 renders the input inside, out of the linter's reach */}
+                <label className="flex items-center gap-2 text-sm">
+                    <span className="w-16 shrink-0">Editor</span>
+
+                    <TextInput
+                        fullWidth
+                        placeholder="Detected automatically, set a path to override it"
+                        value={draft.codeEditorPath}
+                        onChange={event => onChange("codeEditorPath", event.target.value)}
+                    />
+                </label>
+            </GroupBox>
         </div>
     )
 }
diff --git a/src/renderer/components/spaces/Workspace.tsx b/src/renderer/components/spaces/Workspace.tsx
index 7270292..c133abd 100644
--- a/src/renderer/components/spaces/Workspace.tsx
+++ b/src/renderer/components/spaces/Workspace.tsx
@@ -1,3 +1,4 @@
+import { cn } from "@cybearl/cypack/frontend"
 import useResizablePaneWidth from "@renderer/hooks/useResizablePaneWidth"
 import useWindowWidth from "@renderer/hooks/useWindowWidth"
 import { useCallback, useEffect, useMemo } from "react"
@@ -41,15 +42,15 @@ export default function Workspace() {
 
     // Load the persisted files pane width once on mount, clamped by the hook
     useEffect(() => {
-        let cancelled = false
+        let canceled = false
 
         window.api.viewState.get().then(view => {
-            if (cancelled) return
+            if (canceled) return
             setWidth(view.filesPaneWidth)
         })
 
         return () => {
-            cancelled = true
+            canceled = true
         }
     }, [setWidth])
 
@@ -59,7 +60,12 @@ export default function Workspace() {
                 <FilesPane className="shrink-0" style={filesPaneStyle} />
 
                 <div onMouseDown={handleDragStart} className="group relative w-1 shrink-0 cursor-col-resize">
-                    <div className="pointer-events-none absolute inset-y-0 left-1/2 w-px -translate-x-1/2 bg-border-dark group-hover:bg-border-darkest group-active:bg-border-darkest" />
+                    <div
+                        className={cn(
+                            "pointer-events-none absolute inset-y-0 left-1/2 w-px -translate-x-1/2 bg-border-dark",
+                            "group-hover:bg-border-darkest group-active:bg-border-darkest",
+                        )}
+                    />
                 </div>
 
                 <DetailsPane className="min-w-0 flex-1" />
diff --git a/src/renderer/components/ui/TileProgressBar.tsx b/src/renderer/components/ui/TileProgressBar.tsx
index a00cb43..85501d3 100644
--- a/src/renderer/components/ui/TileProgressBar.tsx
+++ b/src/renderer/components/ui/TileProgressBar.tsx
@@ -4,7 +4,7 @@ import styled, { css } from "styled-components"
 
 /**
  * Recolors the tiles to `theme.borderDark` when muted, so
- * the inactive bar shows as light shadow-grey.
+ * the inactive bar shows as light shadow-gray.
  */
 const Wrapper = styled.div<{ $muted: boolean }>`
     display: contents;
diff --git a/src/renderer/config/menus.ts b/src/renderer/config/menus.ts
index 7d6acab..67cae43 100644
--- a/src/renderer/config/menus.ts
+++ b/src/renderer/config/menus.ts
@@ -17,6 +17,7 @@ export type MenuAction =
     | { type: "shell:open-external"; url: string }
     | { type: "shell:show-folder"; path: string }
     | { type: "shell:open-terminal"; path: string }
+    | { type: "shell:open-editor"; path: string }
     | { type: "search:toggle-regex" }
     | { type: "search:toggle-advanced" }
     | { type: "lfs:toggle-show-my-locks" }
@@ -315,6 +316,12 @@ export function buildTopLevelMenus(
                     isDisabled: !currentProject,
                     action: currentProject ? { type: "shell:open-terminal", path: currentProject.path } : undefined,
                 },
+                {
+                    type: "item",
+                    label: "Open in Code Editor",
+                    isDisabled: !currentProject,
+                    action: currentProject ? { type: "shell:open-editor", path: currentProject.path } : undefined,
+                },
                 {
                     type: "item",
                     label: "View on Git Source",
diff --git a/src/renderer/config/preferences.ts b/src/renderer/config/preferences.ts
index f99005f..b65cd8e 100644
--- a/src/renderer/config/preferences.ts
+++ b/src/renderer/config/preferences.ts
@@ -3,10 +3,26 @@
  * displays rather than the milliseconds the preference stores.
  */
 const PREFERENCES_CONFIG = {
-    autoLockIntervalSeconds: { min: 5, max: 600, step: 5 },
-    mcpProbeIntervalSeconds: { min: 1, max: 120, step: 1 },
-    compileDbDebounceSeconds: { min: 1, max: 60, step: 1 },
-    updaterCheckIntervalHours: { min: 1, max: 168, step: 1 },
+    autoLockIntervalSeconds: {
+        min: 5,
+        max: 600,
+        step: 5,
+    },
+    mcpProbeIntervalSeconds: {
+        min: 1,
+        max: 120,
+        step: 1,
+    },
+    compileDbDebounceSeconds: {
+        min: 1,
+        max: 60,
+        step: 1,
+    },
+    updaterCheckIntervalHours: {
+        min: 1,
+        max: 168,
+        step: 1,
+    },
 }
 
 export default PREFERENCES_CONFIG
diff --git a/src/renderer/hooks/useMenuActions.tsx b/src/renderer/hooks/useMenuActions.tsx
index e18d1f5..03731e1 100644
--- a/src/renderer/hooks/useMenuActions.tsx
+++ b/src/renderer/hooks/useMenuActions.tsx
@@ -73,6 +73,12 @@ export default function useMenuActions(): UseMenuActionsResult {
                         .openTerminal(action.path)
                         .catch(error => reportError("Can't open a terminal", error))
 
+                    break
+                case "shell:open-editor":
+                    window.api.shells
+                        .openEditor(action.path)
+                        .catch(error => reportError("Can't open a code editor", error))
+
                     break
                 case "search:toggle-regex":
                     setIsRegex(!isRegex)
diff --git a/src/renderer/hooks/usePreferencesDraft.tsx b/src/renderer/hooks/usePreferencesDraft.tsx
index 76cee76..7b1a9c5 100644
--- a/src/renderer/hooks/usePreferencesDraft.tsx
+++ b/src/renderer/hooks/usePreferencesDraft.tsx
@@ -23,8 +23,6 @@ export default function usePreferencesDraft(): UsePreferencesDraftResult {
     const { preferences } = usePreferences()
     const [draft, setDraft] = useState<AppPreferences>(preferences)
 
-    const isDirty = !arePreferencesEqual(draft, preferences)
-
     /**
      * Records an edit to one field of the draft.
      * @param key The field to change.
@@ -42,5 +40,10 @@ export default function usePreferencesDraft(): UsePreferencesDraftResult {
         await window.api.preferences.set(draft)
     }, [draft])
 
-    return { draft, isDirty, setField, apply }
+    return {
+        draft,
+        isDirty: !arePreferencesEqual(draft, preferences),
+        setField,
+        apply,
+    }
 }
diff --git a/src/renderer/hooks/useResizablePaneWidth.tsx b/src/renderer/hooks/useResizablePaneWidth.tsx
index b68a91e..3cdd1af 100644
--- a/src/renderer/hooks/useResizablePaneWidth.tsx
+++ b/src/renderer/hooks/useResizablePaneWidth.tsx
@@ -117,5 +117,9 @@ export default function useResizablePaneWidth({
         document.addEventListener("mouseup", handleUp)
     }, [])
 
-    return { width, setWidth, handleDragStart }
+    return {
+        width,
+        setWidth,
+        handleDragStart,
+    }
 }
diff --git a/src/renderer/hooks/useUpdaterStatusTask.tsx b/src/renderer/hooks/useUpdaterStatusTask.tsx
index 942d2d1..89c339f 100644
--- a/src/renderer/hooks/useUpdaterStatusTask.tsx
+++ b/src/renderer/hooks/useUpdaterStatusTask.tsx
@@ -14,7 +14,7 @@ export default function useUpdaterStatusTask() {
      */
     const taskRef = useRef<StatusTaskHandle | null>(null)
 
-    // Depends on `startTask` alone, which is stable, since the context value itself
+    // Depends on "startTask" alone, which is stable, since the context value itself
     // changes on every task update and would otherwise tear the task down mid-download
     useEffect(() => {
         const unsubscribe = window.api.updater.onStateChange(state => {
diff --git a/src/renderer/hooks/useWindowStates.tsx b/src/renderer/hooks/useWindowStates.tsx
index 22fc2ab..105399a 100644
--- a/src/renderer/hooks/useWindowStates.tsx
+++ b/src/renderer/hooks/useWindowStates.tsx
@@ -12,16 +12,16 @@ export default function useWindowStates() {
     // Fetch the initial state on mount and subscribe to subsequent changes so
     // the first render already reflects the actual window focus
     useEffect(() => {
-        let cancelled = false
+        let canceled = false
 
         window.api.windows.getState().then(state => {
-            if (!cancelled) setStates(state)
+            if (!canceled) setStates(state)
         })
 
         const unsubscribe = window.api.windows.onStateChange(setStates)
 
         return () => {
-            cancelled = true
+            canceled = true
             unsubscribe()
         }
     }, [])
diff --git a/src/renderer/hooks/useWindowWidth.tsx b/src/renderer/hooks/useWindowWidth.tsx
index b6ede5c..1bcac6d 100644
--- a/src/renderer/hooks/useWindowWidth.tsx
+++ b/src/renderer/hooks/useWindowWidth.tsx
@@ -11,7 +11,12 @@ export default function useWindowWidth(): number {
     // Sample the width again on every resize, the window carries no state change for
     // it and the initial read would otherwise stand for the whole session
     useEffect(() => {
-        const handleResize = () => setWidth(window.innerWidth)
+        /**
+         * Samples the window width again after a resize.
+         */
+        const handleResize = () => {
+            setWidth(window.innerWidth)
+        }
 
         window.addEventListener("resize", handleResize)
         return () => window.removeEventListener("resize", handleResize)
diff --git a/src/renderer/lib/utils/lockStates.ts b/src/renderer/lib/utils/lockStates.ts
index 390d66c..7bea683 100644
--- a/src/renderer/lib/utils/lockStates.ts
+++ b/src/renderer/lib/utils/lockStates.ts
@@ -52,6 +52,7 @@ export function computeLockStates(
 
             const locked = locksByPath.has(node.path)
             states.set(node.path, locked ? "locked" : "unlocked")
+
             return [1, locked ? 1 : 0]
         }
 
@@ -71,6 +72,7 @@ export function computeLockStates(
         else state = "partial"
 
         states.set(node.path, state)
+
         return [lockable, locked]
     }
 
@@ -116,6 +118,7 @@ export function computeLockOwners(
         )
 
         owners.set(node.path, sorted)
+
         return counts
     }
 
diff --git a/src/renderer/lib/utils/menus.ts b/src/renderer/lib/utils/menus.ts
index d2de921..701ed8a 100644
--- a/src/renderer/lib/utils/menus.ts
+++ b/src/renderer/lib/utils/menus.ts
@@ -35,7 +35,12 @@ export function buildComboSignature(combo: KeyCombo): string {
  * @returns The canonical signature string.
  */
 function parseAccelerator(accelerator: string): string {
-    const combo: KeyCombo = { primary: false, shift: false, alt: false, key: "" }
+    const combo: KeyCombo = {
+        primary: false,
+        shift: false,
+        alt: false,
+        key: "",
+    }
 
     for (const token of accelerator.split("+")) {
         switch (token.trim().toLowerCase()) {
diff --git a/src/renderer/lib/utils/search.ts b/src/renderer/lib/utils/search.ts
index d51e61a..7e24e29 100644
--- a/src/renderer/lib/utils/search.ts
+++ b/src/renderer/lib/utils/search.ts
@@ -91,6 +91,7 @@ export function collectMatchingFiles(nodes: FileTreeNode[], filters: SearchFilte
             if (matchesExclude?.(node.path)) return
 
             results.push(node)
+
             return
         }
 
diff --git a/tests/unit/shells.test.ts b/tests/unit/shells.test.ts
new file mode 100644
index 0000000..3237c93
--- /dev/null
+++ b/tests/unit/shells.test.ts
@@ -0,0 +1,38 @@
+import { expandEnvPlaceholders } from "@main/lib/shells/editors"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+
+describe("expandEnvPlaceholders", () => {
+    const originalEnv = process.env
+
+    beforeEach(() => {
+        process.env = {
+            ...originalEnv,
+            LOCALAPPDATA: "C:\\Users\\dev\\AppData\\Local",
+            EMPTYVAR: "",
+        }
+    })
+
+    afterEach(() => {
+        process.env = originalEnv
+    })
+
+    it("expands a placeholder from the environment", () => {
+        expect(expandEnvPlaceholders("%LOCALAPPDATA%\\Programs\\cursor\\Cursor.exe")).toBe(
+            "C:\\Users\\dev\\AppData\\Local\\Programs\\cursor\\Cursor.exe",
+        )
+    })
+
+    it("leaves a candidate holding no placeholder alone", () => {
+        expect(expandEnvPlaceholders("/Applications/Cursor.app")).toBe("/Applications/Cursor.app")
+        expect(expandEnvPlaceholders("code")).toBe("code")
+    })
+
+    it("rules out a candidate whose variable is unset or empty", () => {
+        expect(expandEnvPlaceholders("%NOT_A_REAL_VARIABLE%\\Code.exe")).toBeNull()
+        expect(expandEnvPlaceholders("%EMPTYVAR%\\Code.exe")).toBeNull()
+    })
+
+    it("rules the whole candidate out when only one of its variables is unset", () => {
+        expect(expandEnvPlaceholders("%LOCALAPPDATA%\\%NOT_A_REAL_VARIABLE%\\Code.exe")).toBeNull()
+    })
+})
diff --git a/yarn.lock b/yarn.lock
index 693a128..aca96f4 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7,10 +7,10 @@
   resolved "https://registry.yarnpkg.com/7zip-bin/-/7zip-bin-5.2.0.tgz#7a03314684dd6572b7dfa89e68ce31d60286854d"
   integrity sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==
 
-"@alien_intelligence/eslint-plugin-nitpicker@^0.2.0":
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/@alien_intelligence/eslint-plugin-nitpicker/-/eslint-plugin-nitpicker-0.2.0.tgz#afe513228c7c1132b5420ed7265ac5c283e4edb6"
-  integrity sha512-d8kwa0JvSf3Fqiw22F+Ggffo7V90Z3zh8ezB89ANvAO95pJBEEs67HS8yz7ea2DCVonOr4748VqXIXIrOWt5Dg==
+"@alien_intelligence/eslint-plugin-nitpicker@^0.10.1":
+  version "0.10.1"
+  resolved "https://registry.yarnpkg.com/@alien_intelligence/eslint-plugin-nitpicker/-/eslint-plugin-nitpicker-0.10.1.tgz#e60d9bada450eec1b7e658ceec081bb81b5c3ba8"
+  integrity sha512-8S+8p7xdVVM22ZL49HSn8YQXq94ytsEyoEY/eQ8tDJkbBfb+xPHnlBBi1VHQUKonDnuFASWScpjVUtSzPbfFTA==
   dependencies:
     "@typescript-eslint/utils" "^8.18.0"