diff --git a/CHANGELOG.md b/CHANGELOG.md
index c70e2cff..25c272ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,36 @@
 # Changelog
 
+## 7.8.0
+
+### Open the workspace in VS Code
+
+- **One button, local or remote.** A project row and the file viewer now hand the
+  workspace to your desktop editor. A remote SSH project opens through **VS Code
+  Remote-SSH**, already at the right path — no reconnecting by hand, no hunting for
+  the folder.
+
+- **It opens on the machine you are sitting at.** The studio launches the editor
+  itself when it can find a `code` binary on the host; when it cannot — inside
+  Docker, on a headless server, on Windows — it hands your browser a `vscode://`
+  link instead, and the desktop handler takes it from there. One rule, no
+  platform-sniffing, and it lands correctly whether the studio runs on your laptop
+  or three time zones away.
+
+- **Not only VS Code.** Insiders, VSCodium, Cursor and Windsurf are selectable in
+  Settings → *UI*. All four are VS Code forks, so the remote-SSH link means the same
+  thing in each; only the scheme and the binary change.
+
+- **A remote workspace on a non-standard port carries it.** Omitting the port would
+  not be the cautious choice — the connection would simply be attempted against 22
+  and fail.
+
+- **Refusals say what is wrong.** A remote project recorded with a `~/project`
+  workdir cannot be expressed as a URI (Remote-SSH would look for a directory
+  literally named `~`), so it is refused by name rather than opening the wrong
+  folder. Per-file opening stays local-only on purpose: VS Code's own URL handler
+  opens a remote *file* link as a folder, so the button comes off rather than doing
+  the wrong thing — the project row still opens the remote workspace.
+
 ## 7.7.0
 
 Three things that were true only in one place become true everywhere: the file
diff --git a/CLAUDE.md b/CLAUDE.md
index 1b07f991..afe4dbb4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -20,7 +20,7 @@ docker compose up -d
 docker compose logs -f claude-chat
 ```
 
-No linting and no build step configured. `npm test` chains 63 test files under `test/`: 18 DOM-less render/UI-logic tests (`test/render/*.test.mjs`, run through `node --test`) plus 45 plain-`node` suites in `test/` covering the overload detector, env load order, multi-agent results, terminals, bots, telegram, updates, kanban scheduling, i18n completeness, the config precedence resolver plus its secret masking, usage-limit detection, the filesystem path guard (including the SVG sandbox header and the symlink rule on the `@`-mention search endpoints) plus the tunnel-blocks-terminal rule, WS session re-subscription, the SSH remote CLI-session import, the live engine pane / interactive-prompt watchdog, the cross-project global workspace aggregation, the rule that an SSH credential never leaves the server process, the Windows command-quoting oracle, the auth token lifecycle, the multi-agent dependency scheduler (waves, plan sanitising, and the rule that a failure warning must survive dep-context truncation), the SSH stream parser's three guards, the remote non-interactive shell environment (`remote-env.test.js`, which runs the generated prelude through real `bash -lc`: it must parse, print nothing on stdout, and never end on a false test — the caller chains `&& claude …` behind it), the remote CLI-list framing parser, the bot inbox's SQL seam (`bot-inbox.test.js` pins that `from_bot AS "from"` keeps the exact key `planInboxDelivery` reads — rename one without the other and every letter is silently retired as malformed), the one-time config/.env migration onto CCS_CONFIG_PATH and the mid-task clarification delivery contract on the subscription engine (`interrupt-delivery.test.js` — pins that the tmux injection block sits BEFORE the poll loop's completion `break`, that draining does not imply delivery, that a failed paste is re-queued and warns non-terminally, and that the task runner passes the same callbacks the chat path does), the CLAUDE.md / AGENTS.md discovery rules (`agents-md.test.js`, which also pins that AGENTS.md reaches the subprocess as `--append-system-prompt` and never as `--system-prompt`), and the remote file browser's three guard layers (`remote-files.test.js` runs the generated POSIX script through a real `/bin/sh` against a temp tree that contains symlinks OUT of the project; `remote-files-api.test.js` boots a server against a fake remote via `CCS_REMOTE_EXEC_HOOK` and drives `/api/files` the way the SPA does), and the new-chat defaults chain (`chat-defaults.test.js` pins the pure resolver — the built-ins are asserted to be exactly what the SPA hardcoded before #58, and the choice lists to be exactly the toolbar's `data-v` sets and `MODEL_MAP`'s aliases; `chat-defaults-api.test.js` boots a real server in a throwaway `APP_DIR` and pins that a project writes back a SPARSE override object — a five-key snapshot passes every other assertion in that file and still breaks the feature). On the render side, `tables.test.mjs` also pins the ReDoS bound in renderMd step 3.4, `xss.test.mjs` runs 24 adversarial payloads end-to-end, and `forged-tokens.test.mjs` covers the case where user text contains the renderer's own placeholder control bytes, and `pane-font.test.mjs` pins the clamp DIRECTION of `_fitEnginePaneFont` (a wide engine pane may only shrink; a narrow split pane must be allowed to grow). `script-scope.test.mjs` pins which `<script>` block a helper is declared in — declarations hoist only within their own block, so a helper used by `loadSess()` must not live in the terminal block at the bottom of the file. Note the glob: a file under `test/render/` whose name does not end in `.test.mjs` is NEVER run — `_load.selftest.mjs` sat there unexecuted until it was renamed to `loader.test.mjs`. It runs serially and aborts on the first failing file. `.github/workflows/ci.yml` runs it on every push and PR to `main` (tmux installed, so the four tmux-dependent suites do not self-skip).
+No linting and no build step configured. `npm test` chains 65 test files under `test/`: 18 DOM-less render/UI-logic tests (`test/render/*.test.mjs`, run through `node --test`) plus 47 plain-`node` suites in `test/` covering the overload detector, env load order, multi-agent results, terminals, bots, telegram, updates, kanban scheduling, i18n completeness, the config precedence resolver plus its secret masking, usage-limit detection, the filesystem path guard (including the SVG sandbox header and the symlink rule on the `@`-mention search endpoints) plus the tunnel-blocks-terminal rule, WS session re-subscription, the SSH remote CLI-session import, the live engine pane / interactive-prompt watchdog, the cross-project global workspace aggregation, the rule that an SSH credential never leaves the server process, the Windows command-quoting oracle, the auth token lifecycle, the multi-agent dependency scheduler (waves, plan sanitising, and the rule that a failure warning must survive dep-context truncation), the SSH stream parser's three guards, the remote non-interactive shell environment (`remote-env.test.js`, which runs the generated prelude through real `bash -lc`: it must parse, print nothing on stdout, and never end on a false test — the caller chains `&& claude …` behind it), the remote CLI-list framing parser, the bot inbox's SQL seam (`bot-inbox.test.js` pins that `from_bot AS "from"` keeps the exact key `planInboxDelivery` reads — rename one without the other and every letter is silently retired as malformed), the one-time config/.env migration onto CCS_CONFIG_PATH and the mid-task clarification delivery contract on the subscription engine (`interrupt-delivery.test.js` — pins that the tmux injection block sits BEFORE the poll loop's completion `break`, that draining does not imply delivery, that a failed paste is re-queued and warns non-terminally, and that the task runner passes the same callbacks the chat path does), the CLAUDE.md / AGENTS.md discovery rules (`agents-md.test.js`, which also pins that AGENTS.md reaches the subprocess as `--append-system-prompt` and never as `--system-prompt`), and the remote file browser's three guard layers (`remote-files.test.js` runs the generated POSIX script through a real `/bin/sh` against a temp tree that contains symlinks OUT of the project; `remote-files-api.test.js` boots a server against a fake remote via `CCS_REMOTE_EXEC_HOOK` and drives `/api/files` the way the SPA does), the editor deep links (`editor-links.test.js` pins the two URI shapes literally — the browser link puts `vscode-remote` in the AUTHORITY and the CLI argument puts it in the SCHEME, and collapsing the two silently breaks one path; `editor-open-api.test.js` boots a real server with `PATH` pointed at an EMPTY directory, which both makes the `opened:'client'` fallback deterministic and guarantees the suite never launches an editor window on a developer's desktop), and the new-chat defaults chain (`chat-defaults.test.js` pins the pure resolver — the built-ins are asserted to be exactly what the SPA hardcoded before #58, and the choice lists to be exactly the toolbar's `data-v` sets and `MODEL_MAP`'s aliases; `chat-defaults-api.test.js` boots a real server in a throwaway `APP_DIR` and pins that a project writes back a SPARSE override object — a five-key snapshot passes every other assertion in that file and still breaks the feature). On the render side, `tables.test.mjs` also pins the ReDoS bound in renderMd step 3.4, `xss.test.mjs` runs 24 adversarial payloads end-to-end, and `forged-tokens.test.mjs` covers the case where user text contains the renderer's own placeholder control bytes, and `pane-font.test.mjs` pins the clamp DIRECTION of `_fitEnginePaneFont` (a wide engine pane may only shrink; a narrow split pane must be allowed to grow). `script-scope.test.mjs` pins which `<script>` block a helper is declared in — declarations hoist only within their own block, so a helper used by `loadSess()` must not live in the terminal block at the bottom of the file. Note the glob: a file under `test/render/` whose name does not end in `.test.mjs` is NEVER run — `_load.selftest.mjs` sat there unexecuted until it was renamed to `loader.test.mjs`. It runs serially and aborts on the first failing file. `.github/workflows/ci.yml` runs it on every push and PR to `main` (tmux installed, so the four tmux-dependent suites do not self-skip).
 
 ## Architecture
 
@@ -362,6 +362,51 @@ is testable without booting anything:
   they fire only when a caller passes nothing at all, which is a different concern from
   a channel policy. Pinned by `test/chat-defaults-api.test.js`.
 
+### Open in VS Code (issue #63)
+
+`editor-links.js` builds the links; `POST /api/editor/open` decides which of the two
+ways to launch is right for THIS deployment. Both exist because the studio is not
+always running on the machine the browser is on.
+
+- **The two URI shapes are not the same string.** The browser deep link is
+  `vscode://vscode-remote/ssh-remote+user@host/srv/app` — the editor's scheme, with
+  `vscode-remote` as the URI AUTHORITY, which is how the desktop URL handler routes
+  it. The CLI argument is `--folder-uri vscode-remote://ssh-remote+user@host/srv/app`
+  — there `vscode-remote` IS the scheme, because the editor is already running.
+  Collapse the two and one path silently stops working.
+- **The server prefers its own CLI, and falls back to the deep link.** A resolvable
+  `code` binary means the server is a workstation, so it opens the window itself and
+  can report failure honestly. No binary means Docker, a headless host or Windows —
+  and there the browser follows `vscode://`, which lands on the machine with the
+  screen. That is one rule, no `process.platform` test, correct in every deployment.
+- **Nothing about the deep-link outcome is detectable.** No browser reports whether a
+  protocol handler exists or ran. So the SPA states the condition every time it takes
+  that path ("if nothing opened, …") instead of claiming an error it cannot observe.
+- **`$PATH` is walked in-process, never through `which`/`where`.** A subprocess would
+  need a shell on Windows, and the value being launched is a user-chosen filesystem
+  path — the BatBadBut re-parse `delegate-terminal.js` already had to work around.
+  `_EXEC_EXTS` therefore excludes `.CMD`: VS Code puts `code.cmd` on PATH and Node
+  refuses to spawn one without `shell: true`, so accepting it would turn every Windows
+  launch into a throw instead of the deep-link fallback that works there.
+- **Authorisation is the file browser's resolver, not a second guard.**
+  `resolveFilesWorkdir()` gives "you may open in an editor whatever you may browse",
+  plus the default-`WORKDIR` fallback and — critically — `isRemote` from the PROJECT
+  RECORD. Inferring remoteness from the path would hand a local POSIX-looking workdir
+  to Remote-SSH.
+- **A `~/project` remote workdir is refused by name.** It is legal everywhere else in
+  this app because the remote *shell* expands it; a URI has no shell, and Remote-SSH
+  would look for a directory literally called `~`. Resolving it would need an SSH
+  round trip, which is not something a link builder should do.
+- **Per-FILE open is local-only, and not for the #57 reason.** The remote folder link
+  works; VS Code's URL handler opens a remote FILE uri as a folder
+  (microsoft/vscode-remote-release#4333). So `fpvEditorBtn` hides for a remote file
+  while the project row keeps opening the remote workspace.
+- **The editor is a fixed catalog, not a binary name field.** The value becomes both a
+  URI scheme and an `argv[0]`. `EDITORS` covers VS Code, Insiders, VSCodium, Cursor and
+  Windsurf — all VS Code forks, so `vscode-remote://` means the same thing in each —
+  and the settings row (`config-resolve.js`, `section: 'ui'`) reads its choices from
+  there rather than restating them.
+
 ### Markdown Rendering in SPA
 - During streaming: `renderStreaming()` handles unclosed code fences
 - On `done` event: re-render with full `renderMd()` for proper final formatting
@@ -371,7 +416,7 @@ is testable without booting anything:
 
 ## How to Verify Changes
 
-`npm test` runs 63 test files under `test/` (18 `test/render/*.test.mjs` + 45 `test/*.test.js`), and `.github/workflows/ci.yml` runs the same command on every push and PR to `main`. Nothing covers the live browser/WebSocket path, so also verify that manually:
+`npm test` runs 65 test files under `test/` (18 `test/render/*.test.mjs` + 47 `test/*.test.js`), and `.github/workflows/ci.yml` runs the same command on every push and PR to `main`. Nothing covers the live browser/WebSocket path, so also verify that manually:
 
 ```bash
 # 1. Start server
diff --git a/README.md b/README.md
index f3d54622..e4866ecb 100644
--- a/README.md
+++ b/README.md
@@ -423,6 +423,8 @@ The active engine is always visible at a glance: a **⚡ Max** badge appears in
 
 **SSH** — add remote servers, create projects pointing to directories on them. Claude works there as if local. Type `#` in chat for quick multi-server attachment. Screenshots and files auto-upload via SFTP.
 
+**Open in VS Code** — the ⏻-style button on a project row hands the workspace to your desktop editor, local or over SSH. A remote project opens through **VS Code Remote-SSH** at the right path, without reconnecting by hand. The studio launches the editor itself when it can find a `code` binary; when it cannot — inside Docker, on a headless host, on Windows — it hands your browser a `vscode://` link instead, so the window opens on the machine you are actually sitting at. Pick **VS Code, Insiders, VSCodium, Cursor or Windsurf** in Settings → *UI*. The file viewer gets the same button for the file you are reading.
+
 **Remote file browser** — the file tree, the file viewer and `@`-mention search now work on SSH projects as well, not only local ones. Read-only by design: list a directory, open a file. Download, share and image/PDF preview stay hidden for remote files instead of failing under your finger. Listings are capped at 2000 entries and files at 2 MB — both enforced on the remote host and announced in the UI, so an 8 GB log never crosses the link. A symlink pointing outside the project root is refused, not followed.
 
 **Remote Access** — one click: cloudflared (no signup) or ngrok. Public HTTPS URL in seconds. Works behind NAT, firewalls, corporate VPNs. URL sent to Telegram automatically.
@@ -490,6 +492,7 @@ npx github:Lexus2016/claude-code-studio    # launch as usual
 | **Skills** | 30 built-in, auto-classification, plugin discovery, custom `.md` files |
 | **Commands** | 10 built-in slash commands, custom commands |
 | **Remote** | SSH servers, SFTP upload, `#` quick-attach, cloudflared/ngrok tunnels, remote CLI session import, read-only remote file browser (tree + viewer + `@`-mention search over SSH, capped and symlink-guarded) |
+| **Editor** | Open the active workspace in VS Code / Insiders / VSCodium / Cursor / Windsurf — locally or through Remote-SSH; launched by the server when it has the CLI, by the browser via `vscode://` when it does not |
 | **Mobile** | Native-feel UI, bottom sheet, scroll-snap Kanban, iOS-safe, touch-optimized |
 | **Dashboard** | Activity heatmap, tool usage, model distribution, Automation Index, peak hours |
 | **Reliability** | security-hardened Telegram uploads, self-healing sessions, crash protection, atomic writes, instant stop, rate limit auto-wait, concurrency safety (session lock + busy_timeout), orphaned session lock auto-cleanup |
diff --git a/config-resolve.js b/config-resolve.js
index 7e670636..2a459d6a 100644
--- a/config-resolve.js
+++ b/config-resolve.js
@@ -42,6 +42,7 @@
 'use strict';
 
 const chatDefaults = require('./chat-defaults');
+const editorLinks = require('./editor-links');
 
 // Sources, most-significant first. Ordering here IS the precedence contract;
 // resolve() walks candidates in the order it builds them, not in this order,
@@ -198,6 +199,14 @@ const SETTINGS = [
     choices: ['uk', 'en', 'ru', 'fr', 'he'], def: 'en', falsyFallsThrough: true,
     src: 'server.js:loadMergedConfig' },
 
+  // Which desktop editor the "Open in workspace" action targets (issue #63). A fixed
+  // list rather than a free-text binary name: the value becomes both a URI scheme and
+  // an argv[0], and neither is somewhere to accept arbitrary text. editor-links.js
+  // owns the catalog, so the choices are not restated here.
+  { key: 'editor', section: 'ui', backing: 'config', merge: 'merged', path: 'editor', type: 'enum',
+    choices: editorLinks.EDITOR_IDS, def: editorLinks.DEFAULT_EDITOR, falsyFallsThrough: true,
+    src: 'editor-links.js:editorFor' },
+
   // ── Advanced ──────────────────────────────────────────────────────────────
   { key: 'LOG_LEVEL', section: 'advanced', backing: 'env', type: 'enum',
     choices: ['error', 'warn', 'info', 'debug'], def: 'info', restart: true, src: 'server.js:_logLevel' },
diff --git a/editor-links.js b/editor-links.js
new file mode 100644
index 00000000..f656375b
--- /dev/null
+++ b/editor-links.js
@@ -0,0 +1,190 @@
+'use strict';
+// "Open in VS Code" for the active workspace — issue #63.
+//
+// Two ways exist to put a folder into a desktop editor from a web app, and this
+// project needs BOTH, because the studio is not always running on the machine the
+// browser is on:
+//
+//   1. a `vscode://` deep link, followed by the browser. The editor is launched by
+//      whichever machine is rendering the page — which is, by definition, the
+//      machine with the screen the user is looking at. Nothing can be detected
+//      this way: a browser reports neither that a protocol handler exists nor that
+//      it failed.
+//   2. the `code` CLI, spawned by the server. This one CAN be detected (`--version`
+//      either resolves or it does not), so it is the path that can answer the
+//      issue's "display a clear message" requirement — but it opens a window on the
+//      SERVER host, which is wrong inside Docker, over a tunnel, or from a phone.
+//
+// server.js prefers (2) when an editor binary actually resolves and falls back to
+// (1) otherwise, which lands correctly in every deployment shape without a single
+// `process.platform` test: a container has no `code` on PATH, so it hands the
+// browser a link; a workstation has one, so it opens the window itself.
+//
+// This module is the pure half — flavor catalog, URI construction, path guards —
+// so the format can be pinned without spawning anything (test/editor-links.test.js).
+//
+// THE TWO URI SHAPES ARE NOT THE SAME STRING, and mixing them up is the bug this
+// header exists to prevent:
+//
+//   browser deep link :  vscode://vscode-remote/ssh-remote+user@host/srv/app
+//   CLI argument      :  --folder-uri vscode-remote://ssh-remote+user@host/srv/app
+//
+// In (1) the editor's own scheme is the scheme and `vscode-remote` is the URI
+// AUTHORITY — that is how the desktop URL handler routes it. In (2) `vscode-remote`
+// is the scheme, because at that point the editor is already running and is being
+// handed a workspace URI directly.
+
+const path = require('path');
+
+/**
+ * Editors that register a VS Code-compatible URL handler and ship a CLI. Every one
+ * of them is a VS Code fork, so `vscode-remote://ssh-remote+…` means the same thing
+ * in all of them — only the scheme and the binary name differ. This is the "allow
+ * configuring a custom editor" half of the issue: a fixed list rather than a free
+ * text field, because both values end up in a URI and one of them ends up as an
+ * argv[0], and neither is somewhere to accept arbitrary user text.
+ */
+const EDITORS = {
+  vscode:   { label: 'VS Code',          scheme: 'vscode',          cli: 'code' },
+  insiders: { label: 'VS Code Insiders', scheme: 'vscode-insiders', cli: 'code-insiders' },
+  vscodium: { label: 'VSCodium',         scheme: 'vscodium',        cli: 'codium' },
+  cursor:   { label: 'Cursor',           scheme: 'cursor',          cli: 'cursor' },
+  windsurf: { label: 'Windsurf',         scheme: 'windsurf',        cli: 'windsurf' },
+};
+const DEFAULT_EDITOR = 'vscode';
+const EDITOR_IDS = Object.keys(EDITORS);
+
+/** @param {string} [id] */
+function editorFor(id) {
+  const key = String(id || '').trim();
+  return EDITORS[key] ? { id: key, ...EDITORS[key] } : { id: DEFAULT_EDITOR, ...EDITORS[DEFAULT_EDITOR] };
+}
+
+// Percent-encode one path segment. encodeURIComponent() is too aggressive here: it
+// escapes `:`, and a Windows drive letter is spelled `c:` INSIDE the path of a
+// `vscode://file/c:/…` URI — VS Code's own documentation writes it unescaped, and
+// `%3A` is not recognised. `sub-delims` and `@` are likewise legal in a path segment
+// per RFC 3986, so they are left alone; a space, a `#` or a `?` are not, and one
+// unescaped `#` would truncate the path at the fragment.
+const SAFE_SEGMENT = /[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g;
+function encodeSegment(s) {
+  return String(s).replace(SAFE_SEGMENT, c =>
+    Array.from(Buffer.from(c, 'utf8')).map(b => '%' + b.toString(16).toUpperCase().padStart(2, '0')).join(''));
+}
+
+/** Encode an absolute POSIX-ish path, keeping the separators. */
+function encodePath(p) {
+  return String(p).split('/').map(encodeSegment).join('/');
+}
+
+/**
+ * The SSH authority VS Code Remote-SSH resolves. `user@host` is what the extension's
+ * own quick-pick accepts, and it is also exactly what this project already stores on
+ * a remote host record, so no SSH config alias has to exist on the client.
+ *
+ * A non-22 port is appended. Omitting it is not the safer choice: the connection
+ * would then be attempted against port 22 and fail, whereas `host:port` at worst
+ * fails the same way on an old extension build.
+ */
+function sshAuthority(remoteHost, port) {
+  const h = String(remoteHost || '').trim();
+  if (!h) return '';
+  const p = Number(port);
+  return (p && p !== 22) ? `${h}:${p}` : h;
+}
+
+/** Anything that would let a value break out of the URI, or out of argv. */
+function unsafeValue(s) {
+  // A NUL truncates the C string an exec() finally receives, so everything after it
+  // vanishes — including a part a guard here just approved. The rest are characters
+  // that cannot appear in a real path and would only ever arrive from a crafted
+  // request; a newline in particular would split a URI across two lines.
+  return /[\u0000-\u001f\u007f]/.test(String(s));
+}
+
+/**
+ * Resolve an "open this in the editor" request into the two things server.js needs:
+ * a deep link for the browser and an argv tail for the CLI.
+ *
+ * @param {object} o
+ * @param {string} [o.editor]      — EDITORS key; anything unknown falls back to VS Code
+ * @param {boolean} [o.isRemote]   — the project's own flag, never inferred from the path
+ * @param {string} o.workdir       — project root (local absolute path, or POSIX path on the host)
+ * @param {string} [o.remoteHost]  — `user@host` as stored on the project
+ * @param {number} [o.port]
+ * @param {string} [o.rel]         — path INSIDE the project to open instead of the root
+ * @param {boolean} [o.isFile]     — open `rel` as a file rather than as a folder
+ * @returns {{ok:true, editor:object, kind:'folder'|'file', url:string, cliArgs:string[], target:string}
+ *          |{ok:false, error:string, code:string}}
+ */
+function resolveEditorTarget(o) {
+  const opts = o || {};
+  const editor = editorFor(opts.editor);
+  const workdir = String(opts.workdir == null ? '' : opts.workdir).trim();
+  const rel = String(opts.rel == null ? '' : opts.rel);
+  if (!workdir) return { ok: false, code: 'NO_WORKDIR', error: 'No workspace is active' };
+  if (unsafeValue(workdir) || unsafeValue(rel) || unsafeValue(opts.remoteHost || '')) {
+    return { ok: false, code: 'DENIED', error: 'Denied' };
+  }
+  const kind = (opts.isFile && rel) ? 'file' : 'folder';
+
+  if (opts.isRemote) {
+    const authority = sshAuthority(opts.remoteHost, opts.port);
+    if (!authority) return { ok: false, code: 'NO_HOST', error: 'This remote project has no SSH host recorded' };
+    // Remote paths are resolved with path.posix WHATEVER THIS SERVER RUNS ON — the
+    // same rule remote-files.js exists to keep. path.resolve() on a Windows host
+    // turns '/srv/app' into 'C:\srv\app', which is the #53 failure family, and here
+    // it would additionally be baked into a URI handed to the user's editor.
+    if (!workdir.startsWith('/')) {
+      // A `~/project` workdir is legal everywhere else in this app because the remote
+      // shell expands it. A URI has no shell: Remote-SSH would look for a directory
+      // literally named `~`. Resolving it would need an SSH round trip, which is not
+      // something a link-builder should be doing — so it is refused BY NAME instead
+      // of silently producing a link that opens the wrong folder.
+      return { ok: false, code: 'NOT_ABSOLUTE',
+        error: `VS Code Remote needs an absolute path — this project's workdir is "${workdir}". Re-create it with the full path on the host.` };
+    }
+    if (workdir.includes('\\')) {
+      return { ok: false, code: 'NOT_POSIX', error: 'Remote workdir must be a POSIX path' };
+    }
+    const target = path.posix.resolve(workdir, rel);
+    if (target !== workdir && !target.startsWith(workdir.replace(/\/+$/, '') + '/')) {
+      return { ok: false, code: 'DENIED', error: 'Denied' };
+    }
+    const uriPath = encodePath(target);
+    const auth = `ssh-remote+${encodeSegment(authority)}`;
+    return {
+      ok: true, editor, kind, target,
+      // Browser: the editor's scheme, `vscode-remote` as the authority.
+      url: `${editor.scheme}://vscode-remote/${auth}${uriPath}`,
+      // CLI: `vscode-remote` IS the scheme. --file-uri / --folder-uri rather than a
+      // bare path, because VS Code guesses file-vs-folder from the extension
+      // otherwise and a folder called `app.v2` opens as a file.
+      cliArgs: [kind === 'file' ? '--file-uri' : '--folder-uri', `vscode-remote://${auth}${uriPath}`],
+    };
+  }
+
+  // Local: this path is on the machine running the server, so the platform's own
+  // resolver is the right one.
+  let target;
+  try { target = rel ? path.resolve(workdir, rel) : path.resolve(workdir); }
+  catch { return { ok: false, code: 'DENIED', error: 'Denied' }; }
+  const rootAbs = path.resolve(workdir);
+  const inside = path.relative(rootAbs, target);
+  if (inside !== '' && (inside === '..' || inside.startsWith('..' + path.sep) || path.isAbsolute(inside))) {
+    return { ok: false, code: 'DENIED', error: 'Denied' };
+  }
+  // `vscode://file/` wants forward slashes and no leading one of its own:
+  // 'C:\p\x' -> 'vscode://file/C:/p/x', '/home/u/x' -> 'vscode://file/home/u/x'.
+  const uriPath = encodePath(target.replace(/\\/g, '/').replace(/^\/+/, ''));
+  return {
+    ok: true, editor, kind, target,
+    url: `${editor.scheme}://file/${uriPath}`,
+    // A bare path is what the issue asks for (`code <workspace>`) and what every
+    // fork accepts; the file/folder ambiguity that forces --folder-uri on the remote
+    // side does not exist here, because the CLI can stat it.
+    cliArgs: [target],
+  };
+}
+
+module.exports = { EDITORS, EDITOR_IDS, DEFAULT_EDITOR, editorFor, resolveEditorTarget, sshAuthority, encodePath, encodeSegment };
diff --git a/package.json b/package.json
index 8191ee4d..93780102 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "claude-code-studio",
-  "version": "7.7.0",
+  "version": "7.8.0",
   "description": "Full-featured web workspace for Claude Code — chat, Kanban, multi-agent, MCP, skills, projects",
   "bin": {
     "claude-code-studio": "./bin/cli.js"
@@ -8,7 +8,7 @@
   "scripts": {
     "start": "node server.js",
     "dev": "node --watch server.js",
-    "test": "node --test test/render/*.test.mjs && node test/overload-detector.test.js && node test/usage-limit.test.js && node test/env-load-order.test.js && node test/multi-agent-result.test.js && node test/terminal-session.test.js && node test/terminal-schema.test.js && node test/bots.test.js && node test/bot-inbox.test.js && node test/bots-api.test.js && node test/running-sessions.test.js && node test/session-liveness.test.js && node test/terminal-bridge.integration.test.js && node test/telegram-format.test.js && node test/telegram-behaviour.test.js && node test/ask-user-question.test.js && node test/delegate-terminal.test.js && node test/update-flow.test.js && node test/kanban-schedule.test.js && node test/i18n-completeness.test.js && node test/config-resolve.test.js && node test/chat-defaults.test.js && node test/chat-defaults-api.test.js && node test/setup-gate.test.js && node test/path-guard.test.js && node test/subscribe-nocatchup.test.js && node test/cli-import-remote.test.js && node test/remote-list-parse.test.js && node test/config-migrate.test.js && node test/engine-pane.test.js && node test/global-workspace.test.js && node test/ssh-secret.test.js && node test/agent-dag.test.js && node test/ssh-parser.test.js && node test/remote-env.test.js && node test/remote-files.test.js && node test/remote-files-api.test.js && node test/auth-token.test.js && node test/cmd-model.test.js && node test/origin-guard.test.js && node test/interrupted-recovery.test.js && node test/queue-persistence.test.js && node test/interrupt-idle-config.test.js && node test/agents-md.test.js && node test/interrupt-delivery.test.js && node test/terminal-pane-guard.integration.test.js",
+    "test": "node --test test/render/*.test.mjs && node test/overload-detector.test.js && node test/usage-limit.test.js && node test/env-load-order.test.js && node test/multi-agent-result.test.js && node test/terminal-session.test.js && node test/terminal-schema.test.js && node test/bots.test.js && node test/bot-inbox.test.js && node test/bots-api.test.js && node test/running-sessions.test.js && node test/session-liveness.test.js && node test/terminal-bridge.integration.test.js && node test/telegram-format.test.js && node test/telegram-behaviour.test.js && node test/ask-user-question.test.js && node test/delegate-terminal.test.js && node test/update-flow.test.js && node test/kanban-schedule.test.js && node test/i18n-completeness.test.js && node test/config-resolve.test.js && node test/chat-defaults.test.js && node test/chat-defaults-api.test.js && node test/setup-gate.test.js && node test/path-guard.test.js && node test/subscribe-nocatchup.test.js && node test/cli-import-remote.test.js && node test/remote-list-parse.test.js && node test/config-migrate.test.js && node test/engine-pane.test.js && node test/global-workspace.test.js && node test/ssh-secret.test.js && node test/agent-dag.test.js && node test/ssh-parser.test.js && node test/remote-env.test.js && node test/remote-files.test.js && node test/remote-files-api.test.js && node test/auth-token.test.js && node test/cmd-model.test.js && node test/origin-guard.test.js && node test/interrupted-recovery.test.js && node test/queue-persistence.test.js && node test/interrupt-idle-config.test.js && node test/agents-md.test.js && node test/editor-links.test.js && node test/editor-open-api.test.js && node test/interrupt-delivery.test.js && node test/terminal-pane-guard.integration.test.js",
     "postinstall": "node scripts/install-hooks.js",
     "release": "node scripts/release.js",
     "electron:dev": "electron .",
diff --git a/public/index.html b/public/index.html
index 4563f459..854a0c2a 100644
--- a/public/index.html
+++ b/public/index.html
@@ -3830,6 +3830,10 @@ <h2 id="fpvTitle" style="font-size:14px;font-weight:600;overflow:hidden;text-ove
         <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
         <span data-i18n="fpv.download">Завантажити</span>
       </button>
+      <button class="fpv-btn" id="fpvEditorBtn" data-editor-btn onclick="fpvOpenInEditor()" data-i18n-title="editor.open.file.title" title="Відкрити у редакторі">
+        <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg>
+        <span data-i18n="editor.open">Відкрити</span>
+      </button>
       <button class="fpv-btn" onclick="fpvShare()" id="fpvShareBtn" data-i18n-title="fpv.share.title" title="Поділитись / Скопіювати посилання">
         <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><line x1="8.59" y1="13.51" x2="15.42" y2="17.49"/><line x1="15.41" y1="6.51" x2="8.59" y2="10.49"/></svg>
         <span data-i18n="fpv.share">Поділитись</span>
@@ -4657,6 +4661,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.h.CCS_REMOTE_EXEC_TIMEOUT_MS':'Таймаут однієї команди, виконаної на віддаленому хості через SSH.',
     'cfg.h.CCS_REMOTE_EXEC_MAX_BYTES':'Ліміт обсягу виводу, який приймається від віддаленої команди.',
     'cfg.h.lang':'Мова інтерфейсу.',
+    'cfg.h.editor':'Який редактор відкриває кнопка «Відкрити у…». Усі варіанти — форки VS Code, тож віддалені SSH-проєкти працюють в усіх.',
     'cfg.h.LOG_LEVEL':'Докладність журналу сервера.',
     'cfg.h.NODE_ENV':'Значення production перемикає журнал на JSON із розділенням рядками.',
     'bot.modal.avatar.pick':'Обрати емодзі','bot.modal.avatar.pick.btn':'Обрати','emoji.group.roles':'Ролі','emoji.group.work':'Робота','emoji.group.tools':'Інструменти','emoji.group.ideas':'Ідеї','emoji.group.nature':'Природа',
@@ -4721,6 +4726,11 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'proj.active':'● Активний','proj.inactive':'○ Не активний',
     'proj.active.title':'Активний проект','proj.click.title':'Клік — активувати',
     'proj.del.title':'Видалити проект','proj.rename.title':'Перейменувати проект',
+    'editor.open':'Відкрити','editor.open.title':'Відкрити у {{editor}}',
+    'editor.open.file.title':'Відкрити цей файл у {{editor}}',
+    'editor.opened':'Відкрито у {{editor}}',
+    'editor.hint':'Якщо нічого не відкрилось — {{editor}} не встановлено на цьому комп’ютері (для віддаленого проєкту потрібне ще розширення Remote-SSH).',
+    'editor.failed':'Не вдалося відкрити у {{editor}}',
     'chip.remove':'Видалити',
     'attach.file':'Додати файл (📎)',
     'drop.title':'Відпустіть, щоб прикріпити',
@@ -5039,6 +5049,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.h.CCS_REMOTE_EXEC_TIMEOUT_MS':'Timeout for a single command run on a remote host over SSH.',
     'cfg.h.CCS_REMOTE_EXEC_MAX_BYTES':'Cap on the output accepted from a remote command.',
     'cfg.h.lang':'Interface language.',
+    'cfg.h.editor':'Which editor the \"Open in…\" button targets. Every option is a VS Code fork, so remote SSH projects work in all of them.',
     'cfg.h.LOG_LEVEL':'Server log verbosity.',
     'cfg.h.NODE_ENV':'production switches the log output to newline-delimited JSON.',
     'bot.modal.avatar.pick':'Pick an emoji','bot.modal.avatar.pick.btn':'Pick','emoji.group.roles':'Roles','emoji.group.work':'Work','emoji.group.tools':'Tools','emoji.group.ideas':'Ideas','emoji.group.nature':'Nature',
@@ -5103,6 +5114,11 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'proj.active':'● Active','proj.inactive':'○ Inactive',
     'proj.active.title':'Active project','proj.click.title':'Click to activate',
     'proj.del.title':'Delete project','proj.rename.title':'Rename project',
+    'editor.open':'Open','editor.open.title':'Open in {{editor}}',
+    'editor.open.file.title':'Open this file in {{editor}}',
+    'editor.opened':'Opened in {{editor}}',
+    'editor.hint':'If nothing opened, {{editor}} is not installed on this machine (a remote project also needs the Remote-SSH extension).',
+    'editor.failed':'Could not open in {{editor}}',
     'chip.remove':'Remove',
     'attach.file':'Attach file (📎)',
     'drop.title':'Drop to attach',
@@ -5421,6 +5437,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.h.CCS_REMOTE_EXEC_TIMEOUT_MS':'Таймаут одной команды, выполняемой на удалённом хосте по SSH.',
     'cfg.h.CCS_REMOTE_EXEC_MAX_BYTES':'Лимит объёма вывода, принимаемого от удалённой команды.',
     'cfg.h.lang':'Язык интерфейса.',
+    'cfg.h.editor':'Какой редактор открывает кнопка «Открыть в…». Все варианты — форки VS Code, поэтому удалённые SSH-проекты работают везде.',
     'cfg.h.LOG_LEVEL':'Подробность журнала сервера.',
     'cfg.h.NODE_ENV':'Значение production переключает журнал на JSON с разделением строками.',
     'bot.modal.avatar.pick':'Выбрать эмодзи','bot.modal.avatar.pick.btn':'Выбрать','emoji.group.roles':'Роли','emoji.group.work':'Работа','emoji.group.tools':'Инструменты','emoji.group.ideas':'Идеи','emoji.group.nature':'Природа',
@@ -5485,6 +5502,11 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'proj.active':'● Активен','proj.inactive':'○ Не активен',
     'proj.active.title':'Активный проект','proj.click.title':'Клик — активировать',
     'proj.del.title':'Удалить проект','proj.rename.title':'Переименовать проект',
+    'editor.open':'Открыть','editor.open.title':'Открыть в {{editor}}',
+    'editor.open.file.title':'Открыть этот файл в {{editor}}',
+    'editor.opened':'Открыто в {{editor}}',
+    'editor.hint':'Если ничего не открылось — {{editor}} не установлен на этом компьютере (для удалённого проекта нужно ещё расширение Remote-SSH).',
+    'editor.failed':'Не удалось открыть в {{editor}}',
     'chip.remove':'Удалить',
     'attach.file':'Прикрепить файл (📎)',
     'drop.title':'Отпустите, чтобы прикрепить',
@@ -5803,6 +5825,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.h.CCS_REMOTE_EXEC_TIMEOUT_MS':'Délai d’expiration d’une commande exécutée sur un hôte distant via SSH.',
     'cfg.h.CCS_REMOTE_EXEC_MAX_BYTES':'Limite de sortie acceptée depuis une commande distante.',
     'cfg.h.lang':'Langue de l’interface.',
+    'cfg.h.editor':'L’éditeur ciblé par le bouton « Ouvrir dans… ». Toutes les options sont des forks de VS Code, les projets SSH distants fonctionnent donc partout.',
     'cfg.h.LOG_LEVEL':'Niveau de détail du journal du serveur.',
     'cfg.h.NODE_ENV':'production bascule le journal en JSON délimité par des sauts de ligne.',
     "bot.modal.avatar.pick":"Choisir un émoji","bot.modal.avatar.pick.btn":"Choisir","emoji.group.roles":"Rôles","emoji.group.work":"Travail","emoji.group.tools":"Outils","emoji.group.ideas":"Idées","emoji.group.nature":"Nature",
@@ -5838,7 +5861,12 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     "err.stop.project":"Arrêtez l'agent avant de changer de projet","queue.cancel":"Annuler","queue.save":"Enregistrer","proj.deactivated":"Projet désactivé",
     "load.more":"↑ Charger les messages précédents","logout.confirm":"Se déconnecter ?\n\nToutes les sessions actives resteront enregistrées.",
     "proj.delete.confirm":"Supprimer le projet « {{name}} » ?\n\nLe répertoire NE sera PAS supprimé.","proj.active":"● Actif","proj.inactive":"○ Inactif","proj.active.title":"Projet actif",
-    "proj.click.title":"Cliquez pour activer","proj.del.title":"Supprimer le projet","proj.rename.title":"Renommer le projet","chip.remove":"Retirer","attach.file":"Joindre un fichier (📎)",
+    "proj.click.title":"Cliquez pour activer","proj.del.title":"Supprimer le projet","proj.rename.title":"Renommer le projet",
+    "editor.open":"Ouvrir","editor.open.title":"Ouvrir dans {{editor}}",
+    "editor.open.file.title":"Ouvrir ce fichier dans {{editor}}",
+    "editor.opened":"Ouvert dans {{editor}}",
+    "editor.hint":"Si rien ne s’est ouvert, {{editor}} n’est pas installé sur cette machine (un projet distant nécessite aussi l’extension Remote-SSH).",
+    "editor.failed":"Impossible d’ouvrir dans {{editor}}","chip.remove":"Retirer","attach.file":"Joindre un fichier (📎)",
     "drop.title":"Déposez pour joindre","drop.hint":"Les images et fichiers seront ajoutés à votre message","queue.label":"En file d'attente","queue.edit.title":"Modifier le message",
     "queue.del.title":"Retirer de la file","interrupt.label":"Envoyer comme :","interrupt.stream":"📩 Clarifier en cours","interrupt.queue":"📝 Nouvelle tâche (file d'attente)",
     "interrupt.pill.clarify":"Clarifier","interrupt.pill.queue":"File d'attente","interrupt.pill.clarify.tip":"Cliquez pour passer en mode file d'attente",
@@ -6086,6 +6114,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     'cfg.h.CCS_REMOTE_EXEC_TIMEOUT_MS':'פסק זמן לפקודה בודדת שמורצת על מארח מרוחק דרך SSH.',
     'cfg.h.CCS_REMOTE_EXEC_MAX_BYTES':'מגבלה על הפלט המתקבל מפקודה מרוחקת.',
     'cfg.h.lang':'שפת הממשק.',
+    'cfg.h.editor':'העורך שאליו מכוון הכפתור «פתח ב…». כל האפשרויות הן גרסאות של VS Code, ולכן פרויקטי SSH מרוחקים עובדים בכולן.',
     'cfg.h.LOG_LEVEL':'רמת הפירוט של יומן השרת.',
     'cfg.h.NODE_ENV':'הערך production מעביר את היומן ל-JSON מופרד בשורות.',
     "bot.modal.avatar.pick":"בחרו אמוג׳י","bot.modal.avatar.pick.btn":"בחירה","emoji.group.roles":"תפקידים","emoji.group.work":"עבודה","emoji.group.tools":"כלים","emoji.group.ideas":"רעיונות","emoji.group.nature":"טבע",
@@ -6118,7 +6147,12 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     "err.stop.close":"עצרו את ה-agent לפני הסגירה","err.stop.new":"עצרו את ה-agent לפני פתיחת צ'אט חדש","err.stop.project":"עצרו את ה-agent לפני החלפת פרויקט","queue.cancel":"ביטול","queue.save":"שמירה",
     "proj.deactivated":"הפרויקט הושבת","load.more":"↑ טעינת הודעות קודמות","logout.confirm":"להתנתק?\n\nכל הסשנים הפעילים יישארו שמורים.",
     "proj.delete.confirm":"למחוק את הפרויקט \"{{name}}\"?\n\nהתיקייה לא תימחק.","proj.active":"● פעיל","proj.inactive":"○ לא פעיל","proj.active.title":"פרויקט פעיל","proj.click.title":"לחצו כדי להפעיל",
-    "proj.del.title":"מחיקת פרויקט","proj.rename.title":"שינוי שם פרויקט","chip.remove":"הסרה","attach.file":"צירוף קובץ (📎)","drop.title":"שחררו כאן לצירוף",
+    "proj.del.title":"מחיקת פרויקט","proj.rename.title":"שינוי שם פרויקט",
+    "editor.open":"פתיחה","editor.open.title":"פתיחה ב־{{editor}}",
+    "editor.open.file.title":"פתיחת הקובץ ב־{{editor}}",
+    "editor.opened":"נפתח ב־{{editor}}",
+    "editor.hint":"אם דבר לא נפתח — {{editor}} אינו מותקן במחשב הזה (פרויקט מרוחק דורש גם את התוסף Remote-SSH).",
+    "editor.failed":"לא ניתן לפתוח ב־{{editor}}","chip.remove":"הסרה","attach.file":"צירוף קובץ (📎)","drop.title":"שחררו כאן לצירוף",
     "drop.hint":"תמונות וקבצים יתווספו להודעה שלכם","queue.label":"בתור","queue.edit.title":"עריכת הודעה","queue.del.title":"הסרה מהתור","interrupt.label":"שליחה כ:","interrupt.stream":"📩 הבהרה לנוכחי",
     "interrupt.queue":"📝 משימה חדשה (תור)","interrupt.pill.clarify":"הבהרה","interrupt.pill.queue":"תור","interrupt.pill.clarify.tip":"לחצו למעבר למצב תור",
     "interrupt.pill.queue.tip":"לחצו למעבר למצב הבהרה","interrupt.queued":"ההבהרה נשלחה","interrupt.delivered":"נמסר ל-Claude","interrupt.expired":"המשימה הסתיימה","agents.title":"Agents פעילים",
@@ -11814,6 +11848,9 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
     // Store the global default and resolve the current view's engine. An open
     // chat's explicit run_engine wins; a chat without one inherits this default.
     _globalDefaultEngine = local.defaultEngine === 'subscription' ? 'subscription' : 'api';
+    // Issue #63 — label the "Open in …" buttons with the editor actually configured.
+    if (local.editor && local.editor.label) _editorLabel = local.editor.label;
+    _syncEditorLabels();
     resolveEngineForView();
     // Issue #58: resolve the dials for whatever project the session restored to.
     // Only a brand-new tab is seeded — a restored chat keeps what it was saved with.
@@ -14492,6 +14529,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
   // Restore what a remote file hid, or the next LOCAL file opens with no download.
   $i('fpvDownloadBtn').style.display = '';
   $i('fpvShareBtn').style.display = '';
+  $i('fpvEditorBtn').style.display = '';
 }
 
 async function openFilePreview(relPath, name) {
@@ -14526,6 +14564,12 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
   $i('fpvCopyImgBtn').style.display = (_fpvIsImg && !remote) ? '' : 'none';
   $i('fpvDownloadBtn').style.display = remote ? 'none' : '';
   $i('fpvShareBtn').style.display = remote ? 'none' : '';
+  // Per-FILE open is local-only, and not for the same reason as the two above: the
+  // remote folder link works fine, but VS Code's own URL handler opens a remote FILE
+  // uri as a folder (microsoft/vscode-remote-release#4333). Offering a button that
+  // opens the wrong thing is worse than not offering it — the project row still opens
+  // the remote workspace.
+  $i('fpvEditorBtn').style.display = remote ? 'none' : '';
 
   if (_fpvIsImg && !remote) {
     body.innerHTML = `<img src="${escH(rawUrl)}" alt="${escH(_fpvName)}" onerror="this.alt=t('fpv.img_error')">`;
@@ -14563,6 +14607,14 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
   }
 }
 
+// Open the file currently in the viewer (issue #63). Guarded as well as hidden, the
+// same way fpvDownload() is: the handler is a global and the modal outlives the
+// listing that set _filesRemote.
+function fpvOpenInEditor() {
+  if (!_fpvPath || _filesRemote) return;
+  openInEditor(curWorkdir, _fpvPath, true);
+}
+
 function fpvDownload() {
   // Guarded as well as hidden: the button is display:none for a remote file, but the
   // handler is a global and the modal outlives the listing that set the flag.
@@ -14784,6 +14836,7 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
         <div class="ds" data-tip="${escH(p.isRemote ? (p.remoteHost||'') + ':' + p.workdir : p.workdir)}">${escH(shortPath)}</div>
         <div class="st">${active ? t('proj.active') : t('proj.inactive')}</div>
       </div>
+      <button class="ren" data-editor-btn onclick="event.stopPropagation();openInEditor('${escArg(p.workdir)}')" title="${escH(t('editor.open.title').replace('{{editor}}', _editorLabel))}"><svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" style="vertical-align:-1px"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg></button>
       <button class="ren" onclick="event.stopPropagation();renameProject('${p.id}',this)" title="${t('proj.rename.title')}">✏</button>
       <button class="rm" onclick="event.stopPropagation();delProject('${p.id}')" title="${t('proj.del.title')}">✕</button>`;
     _initProjDrag(div, el);
@@ -14792,6 +14845,49 @@ <h2 id="dlgModalTitle" data-i18n="dlg.title">Делегувати агенту</
   _reapplySecFilter('proj');
 }
 
+// ─── Open the workspace in a desktop editor (issue #63) ────────────────────
+// The server answers one of two ways and the difference matters to the user:
+//   opened:'server' — it found an editor CLI and launched a window itself.
+//   opened:'client' — it found none, and handed back a `vscode://` deep link for
+//                     THIS machine to follow. Nothing can be detected about the
+//                     outcome: a browser reports neither that a protocol handler
+//                     exists nor that it failed. So the hint is shown every time
+//                     that path is taken, phrased as a condition rather than as an
+//                     error — saying "not installed" outright would be a lie on the
+//                     machine where it worked.
+let _editorLabel = 'VS Code';
+
+/** Re-label buttons rendered before /api/version answered. */
+function _syncEditorLabels() {
+  const title = t('editor.open.title').replace('{{editor}}', _editorLabel);
+  document.querySelectorAll('[data-editor-btn]').forEach(b => { b.title = title; });
+}
+
+async function openInEditor(workdir, rel = '', isFile = false) {
+  // An empty workdir is legal and means "the default workspace" — the server resolves
+  // it through the same resolveFilesWorkdir() the file browser uses, so the viewer's
+  // button works before any project has been activated.
+  try {
+    const r = await fetch('/api/editor/open', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ workdir: workdir || '', path: rel, isFile }),
+    });
+    const d = await r.json();
+    if (!r.ok || d.error) { toast(d.error || t('editor.failed').replace('{{editor}}', _editorLabel), true, 6000); return; }
+    if (d.editor) { _editorLabel = d.editor; _syncEditorLabels(); }
+    if (d.opened === 'server') { toast(t('editor.opened').replace('{{editor}}', d.editor || _editorLabel)); return; }
+    // A custom scheme the OS cannot handle is a no-op in every current browser —
+    // it does not navigate away — so location.href is safe here and is the only
+    // form that reliably triggers the desktop handler (an <iframe src> is blocked
+    // for non-http schemes in Chrome).
+    window.location.href = d.url;
+    setTimeout(() => toast(t('editor.hint').replace('{{editor}}', d.editor || _editorLabel), false, 7000), 1200);
+  } catch {
+    toast(t('editor.failed').replace('{{editor}}', _editorLabel), true);
+  }
+}
+
 // ─── Project dropdown in header ────────────────────────────────────────────
 let _projDdOpen = false;
 
diff --git a/server.js b/server.js
index 45d9f5b4..dd8412b6 100644
--- a/server.js
+++ b/server.js
@@ -95,6 +95,9 @@ const agentsMd = require('./agents-md');
 // purpose — see the header of the module.
 const remoteFiles = require('./remote-files');
 const chatDefaults = require('./chat-defaults');
+// "Open in VS Code" (#63). Pure link/argv builder; the spawn half lives next to
+// the endpoint below, because only that half needs the filesystem.
+const editorLinks = require('./editor-links');
 
 // Turn budget for the UNATTENDED execution channels — a Telegram message and a
 // scheduled task. Deliberately NOT wired to `chatDefaults.turns` (#58): that chain
@@ -3017,6 +3020,10 @@ function loadMergedConfig() {
     slashCommands: [...(l.slashCommands||[])],
     lang:          l.lang || g.lang || 'en',
     defaultEngine: l.defaultEngine || g.defaultEngine || 'api',
+    // Which desktop editor "Open in …" targets (#63). `||`, like lang and
+    // defaultEngine: an empty string in a config file means "unset", and
+    // editorFor() falls back once more on an unknown id.
+    editor:        l.editor || g.editor || editorLinks.DEFAULT_EDITOR,
     // Per KEY, not per object: a local config that pins only `model` must not
     // wipe a global `mode`. Same shape as mcpServers/skills above, and it is what
     // the settings catalog reports for chatDefaults.* (merge:'merged').
@@ -5626,7 +5633,10 @@ app.get('/api/version', (_, res) => {
   const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
   // tmuxAvailable: lets the UI disable the "Subscription" engine up front when the
   // server lacks tmux (e.g. native Windows) instead of failing only after a send.
-  res.json({ version: pkg.version, name: pkg.name, tmuxAvailable: tmuxAvailable(), defaultEngine: (loadMergedConfig().defaultEngine === 'subscription' ? 'subscription' : 'api') });
+  // `editor` lets the UI label its button with the editor the user actually
+  // configured ("Open in Cursor") instead of hardcoding VS Code (#63).
+  const _ed = editorLinks.editorFor(loadMergedConfig().editor);
+  res.json({ version: pkg.version, name: pkg.name, tmuxAvailable: tmuxAvailable(), defaultEngine: (loadMergedConfig().defaultEngine === 'subscription' ? 'subscription' : 'api'), editor: { id: _ed.id, label: _ed.label } });
 });
 
 // Capability-checked, never OS-sniffed — the same pattern as tmuxAvailable for the
@@ -5648,6 +5658,81 @@ app.get('/api/terminal/capability', (_, res) => {
   res.json({ available: enabled && tmuxOk && !tunnelOn, reason, reasonKey });
 });
 
+// ─── Open the active workspace in a desktop editor (issue #63) ────────────────
+// Resolution walks $PATH in-process instead of shelling out to `which` / `where`.
+// A subprocess would need a shell on Windows, and a shell is the one thing this
+// must not involve: the value being launched is a filesystem path chosen by the
+// user, and cmd.exe re-parses arguments a second time through the npm .cmd shims
+// (the BatBadBut family the Delegate feature already had to work around).
+//
+// On Windows that same rule makes `code` UNRESOLVABLE on purpose: VS Code puts
+// `code.cmd` on PATH, not `code.exe`, and Node refuses to spawn a .cmd without
+// `shell: true`. So only directly-spawnable extensions count, and Windows simply
+// falls through to the browser deep link — which is the better answer there anyway,
+// since the desktop installer registers the `vscode://` handler.
+const _EXEC_EXTS = process.platform === 'win32' ? ['.EXE', '.COM'] : [''];
+const _editorCliCache = new Map();
+function editorCliPath(bin) {
+  if (_editorCliCache.has(bin)) return _editorCliCache.get(bin);
+  let found = null;
+  for (const dir of String(process.env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    for (const ext of _EXEC_EXTS) {
+      const candidate = path.join(dir, bin + ext);
+      try { fs.accessSync(candidate, fs.constants.X_OK); found = candidate; break; } catch { /* next */ }
+    }
+    if (found) break;
+  }
+  _editorCliCache.set(bin, found);
+  return found;
+}
+
+app.post('/api/editor/open', (req, res) => {
+  const { workdir = '', path: rel = '', isFile = false } = req.body || {};
+  if (typeof workdir !== 'string' || typeof rel !== 'string') {
+    return res.status(400).json({ error: 'workdir and path must be strings' });
+  }
+  // The SAME resolver the file browser uses, deliberately: the rule this endpoint
+  // enforces is "you may open in an editor whatever you may browse". It returns null
+  // for a workdir that is not a registered project (deny), falls back to the default
+  // WORKDIR when the client sends none, and reports isRemote from the PROJECT RECORD
+  // rather than from the shape of the path — a local project whose workdir happens to
+  // look POSIX-absolute must not be handed to Remote-SSH.
+  const resolved = resolveFilesWorkdir(workdir);
+  if (!resolved) return res.status(403).json({ error: 'workdir is outside the allowed roots' });
+
+  const proj = resolved.project;
+  const target = editorLinks.resolveEditorTarget({
+    editor: loadMergedConfig().editor,
+    isRemote: resolved.isRemote,
+    workdir: resolved.workdir,
+    remoteHost: proj ? proj.remoteHost : '',
+    port: proj ? proj.port : 0,
+    rel,
+    isFile: !!isFile,
+  });
+  if (!target.ok) return res.status(400).json({ error: target.error, code: target.code });
+
+  const cli = editorCliPath(target.editor.cli);
+  if (!cli) {
+    // Nothing left to detect and nothing to report as broken: hand the browser the
+    // deep link and let the machine with the screen decide. The SPA says so out loud
+    // afterwards, because no browser reports whether a protocol handler ran.
+    return res.json({ ok: true, opened: 'client', url: target.url, editor: target.editor.label, kind: target.kind });
+  }
+  try {
+    // detached + unref so the editor outlives this process, and stdio ignored so a
+    // chatty CLI cannot fill a pipe nobody is draining.
+    const child = spawnProc(cli, target.cliArgs, { detached: true, stdio: 'ignore' });
+    child.on('error', e => log.warn('editor launch failed', { cli, err: e.message }));
+    child.unref();
+  } catch (e) {
+    log.warn('editor launch threw', { cli, err: e.message });
+    return res.json({ ok: true, opened: 'client', url: target.url, editor: target.editor.label, kind: target.kind });
+  }
+  res.json({ ok: true, opened: 'server', url: target.url, editor: target.editor.label, kind: target.kind });
+});
+
 app.get('/api/health', (_, res) => {
   let dbOk = false;
   try { db.prepare('SELECT 1').get(); dbOk = true; } catch { /* db unavailable */ }
diff --git a/test/editor-links.test.js b/test/editor-links.test.js
new file mode 100644
index 00000000..2514727c
--- /dev/null
+++ b/test/editor-links.test.js
@@ -0,0 +1,208 @@
+// "Open in VS Code" — issue #63.
+//
+// The whole feature is one string per case, and a string that is subtly wrong opens
+// the WRONG FOLDER on the user's machine rather than failing. So the URI shapes are
+// pinned literally here, not described.
+//
+// The invariant this file exists for: the browser deep link and the CLI argument are
+// NOT the same URI.
+//
+//   browser :  vscode://vscode-remote/ssh-remote+user@host/srv/app
+//   CLI     :  --folder-uri vscode-remote://ssh-remote+user@host/srv/app
+//
+// In the first, the editor's own scheme is the scheme and `vscode-remote` is the
+// authority — that is how the desktop URL handler routes it. In the second,
+// `vscode-remote` IS the scheme, because the editor is already running. Collapse the
+// two and one of the paths silently stops working, in a way no test that only checks
+// "contains ssh-remote" would notice.
+//
+// Run: node test/editor-links.test.js
+'use strict';
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const E = require('../editor-links');
+
+let pass = 0, fail = 0;
+function check(label, actual, expected) {
+  try { assert.deepStrictEqual(actual, expected); pass++; console.log(`  ok   ${label}`); }
+  catch { fail++; console.error(`  FAIL ${label} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
+}
+
+const local  = o => E.resolveEditorTarget({ workdir: '/home/u/app', ...o });
+const remote = o => E.resolveEditorTarget({ isRemote: true, workdir: '/srv/app', remoteHost: 'deploy@10.0.0.5', ...o });
+
+// ── 1. The two shapes ────────────────────────────────────────────────────────
+console.log('\nthe deep link and the CLI argument are different URIs:');
+{
+  const r = remote({});
+  check('the browser link puts vscode-remote in the AUTHORITY',
+    r.url, 'vscode://vscode-remote/ssh-remote+deploy@10.0.0.5/srv/app');
+  check('the CLI argument puts it in the SCHEME',
+    r.cliArgs, ['--folder-uri', 'vscode-remote://ssh-remote+deploy@10.0.0.5/srv/app']);
+  // --folder-uri and not a bare path: VS Code guesses file-vs-folder from the
+  // extension, so a directory named `app.v2` opens as a file.
+  check('a remote FILE uses --file-uri, not --folder-uri',
+    remote({ rel: 'src/index.js', isFile: true }).cliArgs,
+    ['--file-uri', 'vscode-remote://ssh-remote+deploy@10.0.0.5/srv/app/src/index.js']);
+  check('and its kind says so', remote({ rel: 'a.js', isFile: true }).kind, 'file');
+  check('a rel path without isFile is still a folder', remote({ rel: 'src' }).kind, 'folder');
+
+  const l = local({});
+  check('a local project is a plain file: URI', l.url, 'vscode://file/home/u/app');
+  check('and the CLI just gets the path — `code <workspace>`', l.cliArgs, ['/home/u/app']);
+}
+
+// ── 2. The SSH authority ─────────────────────────────────────────────────────
+console.log('\nthe SSH authority carries the port only when it is not 22:');
+{
+  check('port 22 is left off — it is the default on both sides',
+    E.sshAuthority('u@h', 22), 'u@h');
+  check('an absent port likewise', E.sshAuthority('u@h', 0), 'u@h');
+  // Omitting a non-standard port is NOT the safe choice: the connection would then
+  // be attempted against 22 and fail. `host:port` at worst fails the same way.
+  check('a non-standard port is appended', E.sshAuthority('u@h', 2222), 'u@h:2222');
+  check('and it reaches the URI',
+    remote({ port: 2222 }).url, 'vscode://vscode-remote/ssh-remote+deploy@10.0.0.5:2222/srv/app');
+  check('a remote project with no host recorded is refused by name',
+    E.resolveEditorTarget({ isRemote: true, workdir: '/srv/app' }).code, 'NO_HOST');
+}
+
+// ── 3. Encoding ──────────────────────────────────────────────────────────────
+console.log('\npath encoding keeps a URI a URI, and a drive letter a drive letter:');
+{
+  check('a space becomes %20', local({ workdir: '/home/u/my app' }).url, 'vscode://file/home/u/my%20app');
+  // One unescaped '#' truncates the path at the fragment — the editor would open the
+  // parent folder instead, silently.
+  check('a # is escaped, or the path ends there',
+    local({ workdir: '/home/u/c#proj' }).url, 'vscode://file/home/u/c%23proj');
+  check('a ? is escaped too', local({ workdir: '/home/u/a?b' }).url, 'vscode://file/home/u/a%3Fb');
+  check('non-ASCII is UTF-8 percent-encoded', E.encodeSegment('café'), 'caf%C3%A9');
+  // encodeURIComponent() would write %3A here. VS Code's own docs spell it
+  // `vscode://file/c:/myProject`, and %3A is not recognised.
+  check('a colon survives — a Windows drive letter lives INSIDE the path',
+    E.encodeSegment('c:'), 'c:');
+  check('and @ survives, because the authority is user@host', E.encodeSegment('u@h'), 'u@h');
+  check('separators are not encoded away', E.encodePath('/a b/c'), '/a%20b/c');
+}
+
+// ── 4. Guards ────────────────────────────────────────────────────────────────
+console.log('\nwhat it refuses, and why the refusal is by name:');
+{
+  // A `~/project` workdir is legal everywhere else in this app because the remote
+  // SHELL expands it. A URI has no shell: Remote-SSH would look for a directory
+  // literally called `~`. Refusing beats opening the wrong folder.
+  const tilde = E.resolveEditorTarget({ isRemote: true, workdir: '~/app', remoteHost: 'u@h' });
+  check('a ~-relative remote workdir is refused', tilde.ok, false);
+  check('with a code the UI can branch on', tilde.code, 'NOT_ABSOLUTE');
+  check('and a message that names the workdir', /~\/app/.test(tilde.error), true);
+
+  check('a backslash in a remote workdir is refused',
+    E.resolveEditorTarget({ isRemote: true, workdir: '/srv\\app', remoteHost: 'u@h' }).code, 'NOT_POSIX');
+  // A NUL truncates the C string exec() finally receives, so everything after it
+  // vanishes — including a part a guard here just approved.
+  check('a NUL anywhere is denied', local({ workdir: '/home/u/a\u0000b' }).code, 'DENIED');
+  check('a newline is denied — it would split the URI', local({ rel: 'a\nb' }).code, 'DENIED');
+  check('a control char in the host is denied',
+    E.resolveEditorTarget({ isRemote: true, workdir: '/srv/app', remoteHost: 'u@h\r' }).code, 'DENIED');
+  check('an empty workdir is refused', E.resolveEditorTarget({}).code, 'NO_WORKDIR');
+
+  // rel is a path from the browser. It is contained on BOTH sides, and the remote
+  // side uses path.posix so a Windows HOST cannot turn '/srv/app' into 'C:\srv\app'
+  // (the #53 failure family) before the check runs.
+  check('a remote rel cannot climb out', remote({ rel: '../../etc' }).code, 'DENIED');
+  check('a local rel cannot either', local({ rel: '../../etc' }).code, 'DENIED');
+  check('a rel that stays inside is fine', remote({ rel: 'src/a.js' }).target, '/srv/app/src/a.js');
+  check('the project root itself is inside itself', local({ rel: '.' }).ok, true);
+  check('remote resolution is POSIX, never this platform',
+    remote({ rel: 'src/./x/../a.js' }).target, '/srv/app/src/a.js');
+}
+
+// ── 5. The editor catalog ────────────────────────────────────────────────────
+console.log('\nthe editor catalog is a fixed list, not free text:');
+{
+  // The value becomes both a URI scheme and an argv[0]. Neither is somewhere to
+  // accept arbitrary user text, so an unknown id falls back rather than being used.
+  check('an unknown id falls back to VS Code', E.editorFor('emacs').id, 'vscode');
+  check('as does an empty one', E.editorFor('').id, 'vscode');
+  check('as does undefined', E.editorFor().id, 'vscode');
+  check('the default is VS Code', E.DEFAULT_EDITOR, 'vscode');
+  check('every catalogued id has a scheme and a CLI',
+    E.EDITOR_IDS.filter(id => !E.EDITORS[id].scheme || !E.EDITORS[id].cli || !E.EDITORS[id].label), []);
+  check('Insiders has its own scheme', E.editorFor('insiders').scheme, 'vscode-insiders');
+  check('and its own binary', E.editorFor('insiders').cli, 'code-insiders');
+  check('a fork changes only the scheme — vscode-remote means the same thing in all of them',
+    remote({ editor: 'cursor' }).url, 'cursor://vscode-remote/ssh-remote+deploy@10.0.0.5/srv/app');
+  check('the CLI side of a fork keeps the vscode-remote scheme',
+    remote({ editor: 'cursor' }).cliArgs[1], 'vscode-remote://ssh-remote+deploy@10.0.0.5/srv/app');
+  check('the resolved editor rides along for the UI label', local({ editor: 'windsurf' }).editor.label, 'Windsurf');
+}
+
+// ── 6. The server wiring ─────────────────────────────────────────────────────
+// Source-level, like config-resolve.test.js's operator guard: these are decisions
+// that a later edit would silently undo, and none of them is observable from the
+// pure module.
+console.log('\nthe wiring in server.js:');
+{
+  const SRC = fs.readFileSync(path.join(__dirname, '..', 'server.js'), 'utf8');
+  const start = SRC.indexOf("app.post('/api/editor/open'");
+  check('the endpoint exists', start > -1, true);
+  const body = SRC.slice(start, SRC.indexOf("\n});\n", start));
+
+  // Reusing the file browser's resolver IS the access rule: "you may open in an
+  // editor whatever you may browse". A bespoke second guard here would be a second
+  // thing to keep in sync with isPathAllowed().
+  check('it authorises through the file browser resolver', /resolveFilesWorkdir\(workdir\)/.test(body), true);
+  check('and denies when that resolver says no', /if \(!resolved\) return res\.status\(403\)/.test(body), true);
+  // isRemote must come from the PROJECT RECORD. Inferring it from the path would
+  // hand a local POSIX-looking workdir to Remote-SSH.
+  check('isRemote comes from the resolved project, not from the path',
+    /isRemote: resolved\.isRemote/.test(body), true);
+
+  // A shell is the one thing this must not involve: the value being launched is a
+  // filesystem path, and cmd.exe re-parses arguments a second time through the npm
+  // .cmd shims (the BatBadBut family delegate-terminal.js already had to work around).
+  check('the spawn never goes through a shell', /shell\s*:/.test(body), false);
+  check('the editor outlives this process', /detached: true/.test(body), true);
+  check('a missing CLI is a client-side deep link, not an error',
+    /opened: 'client'/.test(body), true);
+
+  // Windows puts `code.cmd` on PATH, not `code.exe`, and Node refuses to spawn a
+  // .cmd without shell:true. Accepting .CMD here would therefore not "add Windows
+  // support" — it would make every Windows launch throw instead of falling through
+  // to the deep link, which is the better answer there anyway.
+  const exts = SRC.match(/const _EXEC_EXTS = [^\n]+/)[0];
+  check('only directly-spawnable extensions count on Windows', /\.CMD|\.BAT/.test(exts), false);
+  check('and the POSIX side uses a bare name', /\[''\]/.test(exts), true);
+
+  // falsyFallsThrough on the catalog row claims `||`; config-resolve.test.js reads
+  // the operator out of this line, so it has to be here at all.
+  check('loadMergedConfig resolves `editor` with ||',
+    /^\s*editor:\s*l\.editor \|\| g\.editor \|\| /m.test(SRC), true);
+  check('/api/version reports the configured editor for the button label',
+    /editor: \{ id: _ed\.id, label: _ed\.label \}/.test(SRC), true);
+}
+
+// ── 7. The SPA gating ────────────────────────────────────────────────────────
+console.log('\nthe per-file button is local-only, for a different reason than download is:');
+{
+  const HTML = fs.readFileSync(path.join(__dirname, '..', 'public', 'index.html'), 'utf8');
+  // The remote FOLDER link works. VS Code's URL handler mis-handles a remote FILE
+  // uri — it opens it as a folder (microsoft/vscode-remote-release#4333) — so the
+  // viewer's button comes off for a remote file while the project row keeps working.
+  check('the viewer button is hidden for a remote file',
+    /\$i\('fpvEditorBtn'\)\.style\.display = remote \? 'none' : '';/.test(HTML), true);
+  // Hidden is not guarded: the handler is a global and the modal outlives the
+  // listing that set the flag.
+  check('and the handler refuses one as well',
+    /function fpvOpenInEditor\(\) \{\s*\n\s*if \(!_fpvPath \|\| _filesRemote\) return;/.test(HTML), true);
+  check('the project row opens the workspace, remote or not',
+    /openInEditor\('\$\{escArg\(p\.workdir\)\}'\)/.test(HTML), true);
+  // No browser reports whether a protocol handler ran, so the hint is shown every
+  // time that path is taken — phrased as a condition, not as an error.
+  check('the deep-link path always says what to check',
+    /setTimeout\(\(\) => toast\(t\('editor\.hint'\)/.test(HTML), true);
+}
+
+console.log(`\n${fail === 0 ? 'PASS' : 'FAIL'} — ${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);
diff --git a/test/editor-open-api.test.js b/test/editor-open-api.test.js
new file mode 100644
index 00000000..dda6883b
--- /dev/null
+++ b/test/editor-open-api.test.js
@@ -0,0 +1,166 @@
+// POST /api/editor/open against a REAL server — issue #63.
+//
+// editor-links.test.js pins the URI strings and reads the wiring out of the source.
+// Neither statement proves the endpoint answers, that the workdir it authorises is
+// the one it builds a link for, or that a remote project's host and port survive the
+// trip from data/projects.json into the URI. This boots server.js in a throwaway
+// APP_DIR and drives it the way the SPA does.
+//
+// PATH is deliberately pointed at an EMPTY directory. Two reasons, and the second is
+// not optional: it makes `opened:'client'` deterministic instead of depending on
+// whether the machine running the tests has VS Code, and it guarantees the suite
+// never actually launches an editor window on a developer's desktop.
+//
+// Run: node test/editor-open-api.test.js   (TEST_PORT=<n> to move off the default port)
+'use strict';
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const E = require('../editor-links');
+
+let pass = 0, fail = 0;
+function check(label, actual, expected) {
+  try { assert.deepStrictEqual(actual, expected); pass++; console.log(`  ok   ${label}`); }
+  catch { fail++; console.error(`  FAIL ${label} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
+}
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+const PORT = Number(process.env.TEST_PORT || 4537);
+const BASE = `http://127.0.0.1:${PORT}`;
+
+const APP_DIR  = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-edapi-app-'));
+const HOME_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-edapi-home-'));
+const NO_PATH  = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-edapi-nopath-'));
+process.on('exit', () => { for (const d of [APP_DIR, HOME_DIR, NO_PATH]) { try { fs.rmSync(d, { recursive: true, force: true }); } catch {} } });
+fs.mkdirSync(path.join(APP_DIR, 'data'), { recursive: true });
+
+const WORKSPACE = path.join(APP_DIR, 'workspace');
+const LOCAL_PROJ = path.join(APP_DIR, 'workspace', 'local proj');   // a space, so the encoder is exercised end to end
+fs.mkdirSync(path.join(LOCAL_PROJ, 'src'), { recursive: true });
+fs.writeFileSync(path.join(LOCAL_PROJ, 'src', 'index.js'), '//\n');
+const REMOTE_WD = '/srv/deploy/app';
+
+let srvLog = '';
+const child = spawn(process.execPath, [path.join(__dirname, '..', 'server.js')], {
+  env: {
+    ...process.env,
+    PORT: String(PORT), CCS_DESKTOP: '1', APP_DIR, WORKDIR: WORKSPACE, HOME: HOME_DIR,
+    PATH: NO_PATH,
+  },
+  stdio: ['ignore', 'pipe', 'pipe'],
+});
+let exited = false;
+child.on('exit', () => { exited = true; });
+child.stdout.on('data', d => { srvLog += d; });
+child.stderr.on('data', d => { srvLog += d; });
+
+let cleanedUp = false;
+function cleanup() { if (cleanedUp) return; cleanedUp = true; if (!exited) { try { child.kill('SIGTERM'); } catch {} } }
+process.on('exit', cleanup);
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(sig, () => { cleanup(); process.exit(1); });
+function die(msg) { console.error(msg); if (srvLog) console.error(srvLog.slice(-2000)); cleanup(); process.exit(1); }
+
+async function api(method, url, body) {
+  const res = await fetch(BASE + url, {
+    method,
+    headers: body ? { 'content-type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json = null; try { json = JSON.parse(text); } catch {}
+  return { status: res.status, json, text };
+}
+const open = body => api('POST', '/api/editor/open', body);
+
+(async () => {
+  let up = false;
+  for (let i = 0; i < 80 && !exited; i++) {
+    try { const r = await fetch(BASE + '/api/health'); if (r.ok) { up = true; break; } } catch {}
+    await sleep(250);
+  }
+  if (exited) die(`server exited before it became ready — port ${PORT} collision or startup crash`);
+  if (!up) die(`server on port ${PORT} did not start`);
+  if (!(srvLog.includes('server started') && new RegExp(`"port":\\s*"?${PORT}"?`).test(srvLog))) {
+    die(`something answers /api/health on ${PORT} but our server never logged "server started"`);
+  }
+
+  const localProj = await api('POST', '/api/projects', { name: 'local', workdir: LOCAL_PROJ, gitInit: false });
+  if (localProj.status !== 200) die(`could not create the local project: ${localProj.text}`);
+  const host = await api('POST', '/api/remote-hosts', { label: 'box', host: 'deploy@10.0.0.5', port: 2222 });
+  if (host.status !== 200 || !host.json?.id) die(`could not create the remote host: ${host.text}`);
+  const remoteProj = await api('POST', '/api/projects', { name: 'remote', workdir: REMOTE_WD, isRemote: true, remoteHostId: host.json.id });
+  if (remoteProj.status !== 200) die(`could not create the remote project: ${remoteProj.text}`);
+
+  console.log('\n— a local workspace —');
+  const l = await open({ workdir: LOCAL_PROJ });
+  check('it answers 200', l.status, 200);
+  // With no editor binary reachable there is nothing left to detect, so the browser
+  // is handed the link. This is the Docker / headless / Windows path.
+  check('and hands the browser the deep link', l.json.opened, 'client');
+  // fs.realpathSync, not the literal: on macOS $TMPDIR lives under /private, and the
+  // server resolves the project root before building the link. Comparing against the
+  // unresolved path would pass on Linux and fail here.
+  check('the link names the real workspace path',
+    l.json.url, 'vscode://file' + E.encodePath(fs.realpathSync(LOCAL_PROJ).replace(/\\/g, '/')));
+  check('the space in the path really did get encoded', l.json.url.includes('%20'), true);
+  check('it is a folder', l.json.kind, 'folder');
+  check('and the label is the configured editor', l.json.editor, 'VS Code');
+
+  console.log('\n— a file inside it —');
+  const f = await open({ workdir: LOCAL_PROJ, path: 'src/index.js', isFile: true });
+  check('opening a file is a file', f.json.kind, 'file');
+  check('and the link points at it', f.json.url.endsWith('/src/index.js'), true);
+
+  console.log('\n— a remote SSH workspace —');
+  const r = await open({ workdir: REMOTE_WD });
+  check('a remote project resolves too', r.status, 200);
+  // The host and the non-standard port made it out of data/projects.json and into the
+  // authority. Dropping the port would not be the cautious choice — the connection
+  // would then be attempted against 22 and fail.
+  check('through Remote-SSH, at the recorded host and port',
+    r.json.url, 'vscode://vscode-remote/ssh-remote+deploy@10.0.0.5:2222/srv/deploy/app');
+  // The POSIX path was NOT run through path.resolve(): on a Windows host that turns
+  // '/srv/deploy/app' into 'C:\srv\deploy\app' — the #53 failure family, here baked
+  // into a link handed to the user's editor.
+  check('the remote path is untouched by local platform rules',
+    r.json.url.includes('/srv/deploy/app'), true);
+
+  console.log('\n— what it refuses —');
+  const stranger = await open({ workdir: path.join(os.tmpdir(), 'not-a-project') });
+  check('a workdir that is not a registered project is refused', stranger.status, 403);
+  const climb = await open({ workdir: LOCAL_PROJ, path: '../../../etc' });
+  check('a rel path cannot climb out of the project', climb.status, 400);
+  check('and says so with a code', climb.json.code, 'DENIED');
+  const nul = await open({ workdir: LOCAL_PROJ, path: 'a\u0000b' });
+  check('a NUL in the path is refused', nul.status, 400);
+  const notString = await open({ workdir: LOCAL_PROJ, path: { a: 1 } });
+  check('a non-string path is a 400, not a 500', notString.status, 400);
+
+  console.log('\n— no project at all —');
+  // The file browser answers for the default WORKDIR when the client sends no
+  // workdir, and this endpoint reuses its resolver, so it has to do the same — the
+  // viewer button works before any project is activated.
+  const dflt = await open({});
+  check('an omitted workdir falls back to the default workspace', dflt.status, 200);
+  check('naming that workspace', dflt.json.url, 'vscode://file' + E.encodePath(fs.realpathSync(WORKSPACE).replace(/\\/g, '/')));
+
+  console.log('\n— the configured editor reaches the URI —');
+  // The scheme is the ONLY thing a fork changes; `vscode-remote` means the same in
+  // all of them. Written through the settings endpoint rather than by editing the
+  // file, so the config cache invalidation is part of what is being tested.
+  const put = await api('PUT', '/api/config/setting', { key: 'editor', value: 'cursor' });
+  check('the setting is writable from the settings form', put.status, 200);
+  const c = await open({ workdir: LOCAL_PROJ });
+  check('a local link switches scheme', c.json.url.startsWith('cursor://file/'), true);
+  check('and so does a remote one, keeping vscode-remote as the authority',
+    (await open({ workdir: REMOTE_WD })).json.url,
+    'cursor://vscode-remote/ssh-remote+deploy@10.0.0.5:2222/srv/deploy/app');
+  check('the label follows, so the button does not still say VS Code',
+    (await api('GET', '/api/version')).json.editor, { id: 'cursor', label: 'Cursor' });
+
+  cleanup();
+  console.log(`\n${fail === 0 ? 'PASS' : 'FAIL'} — ${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => die(e && e.stack || String(e)));