diff --git a/apps/server/src/bin.ts b/apps/server/src/bin.ts
index 063093874503..0cecf7595b72 100644
--- a/apps/server/src/bin.ts
+++ b/apps/server/src/bin.ts
@@ -5,7 +5,8 @@
  * terminal-fallback agents run `t3 acp-mcp-call` per tool call, so their
  * startup sits on first-message latency. Both dispatch here before the full
  * CLI module graph (seconds of evaluation) loads; everything else defers to
- * the real CLI in ./binCli.ts.
+ * the real CLI in ./binCli.ts. `t3 __run-node-script` runs bundled language
+ * servers under the single-executable build (see ./nodeScript.ts).
  */
 import { isEntrypoint } from "./entrypoint.ts";
 
@@ -20,6 +21,9 @@ if (
   if (command === "acp-mcp-bridge" || command === "acp-mcp-call") {
     const { runAcpMcpCliFastPath } = await import("./mcp/AcpMcpStdioBridge.ts");
     await runAcpMcpCliFastPath(command, process.argv.slice(3));
+  } else if (command === "__run-node-script") {
+    const { runNodeScript } = await import("./nodeScript.ts");
+    runNodeScript(process.argv.slice(3));
   } else {
     const { runCli } = await import("./binCli.ts");
     runCli();
diff --git a/apps/server/src/nodeScript.test.ts b/apps/server/src/nodeScript.test.ts
new file mode 100644
index 000000000000..b5b49b82dd00
--- /dev/null
+++ b/apps/server/src/nodeScript.test.ts
@@ -0,0 +1,35 @@
+// @effect-diagnostics nodeBuiltinImport:off - runs a CommonJS script from the filesystem.
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import { afterEach, describe, expect, it } from "vite-plus/test";
+
+import { runNodeScript } from "./nodeScript.ts";
+
+describe("runNodeScript", () => {
+  const originalArgv = process.argv;
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it("runs the script with the argv Node would give it", () => {
+    const directory = NodeFS.realpathSync(
+      NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-node-script-")),
+    );
+    const script = NodePath.join(directory, "server.cjs");
+    const output = NodePath.join(directory, "argv.json");
+    NodeFS.writeFileSync(
+      script,
+      `require("node:fs").writeFileSync(${JSON.stringify(output)}, JSON.stringify({ argv: process.argv.slice(1), filename: __filename }));`,
+    );
+
+    runNodeScript([script, "--stdio"]);
+
+    expect(JSON.parse(NodeFS.readFileSync(output, "utf8"))).toEqual({
+      argv: [script, "--stdio"],
+      filename: script,
+    });
+    NodeFS.rmSync(directory, { recursive: true, force: true });
+  });
+});
diff --git a/apps/server/src/nodeScript.ts b/apps/server/src/nodeScript.ts
new file mode 100644
index 000000000000..2ab8564dead7
--- /dev/null
+++ b/apps/server/src/nodeScript.ts
@@ -0,0 +1,23 @@
+// @effect-diagnostics nodeBuiltinImport:off
+// Runs before any Effect runtime is built, so it stays on Node built-ins.
+import * as NodeModule from "node:module";
+import * as NodeSea from "node:sea";
+
+/**
+ * How to run a JavaScript file shipped with T3 (tsserver, Pyright) on T3's own runtime.
+ * The single-executable build always starts its embedded entry and ignores a script
+ * argument, so it goes through `t3 __run-node-script`, which loads the script itself.
+ */
+export function nodeScriptCommand(script: string, args: ReadonlyArray<string>) {
+  return {
+    command: process.execPath,
+    args: NodeSea.isSea() ? ["__run-node-script", script, ...args] : [script, ...args],
+  };
+}
+
+/** Entry for `t3 __run-node-script <script> [args]`: runs the script as if Node started it. */
+export function runNodeScript([script, ...args]: ReadonlyArray<string>) {
+  if (!script) throw new Error("Usage: t3 __run-node-script <script> [args...]");
+  process.argv = [process.execPath, script, ...args];
+  NodeModule.createRequire(script)(script);
+}
diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts
index cde3582e5334..2aac0f581a48 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.test.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts
@@ -332,7 +332,7 @@ it.effect("uses stable diagnostics for every parsed non-repository command", ()
 
     assert.deepStrictEqual(commands, [
       { args: ["rev-parse", "--git-path", "index"], lcAll: "C" },
-      { args: ["status", "--porcelain=2", "--branch"], lcAll: "C" },
+      { args: ["status", "--porcelain=2", "-z", "--branch"], lcAll: "C" },
       { args: ["rev-parse", "--abbrev-ref", "HEAD"], lcAll: "C" },
       { args: ["rev-parse", "--git-common-dir"], lcAll: "C" },
     ]);
@@ -357,6 +357,59 @@ it.effect("invalidates origin remote cache when a driver mutation adds origin",
   }).pipe(Effect.provide(TestLayer)),
 );
 
+it.effect("lists each working tree change once, including renames", () =>
+  Effect.gen(function* () {
+    const driver = yield* GitVcsDriver.GitVcsDriver;
+    const cwd = yield* makeTmpDir();
+    yield* initRepoWithCommit(cwd);
+    yield* writeTextFile(cwd, "apps/desktop/src/moved.ts", "one\ntwo\n");
+    yield* writeTextFile(cwd, "apps/desktop/src/edited.ts", "one\ntwo\nthree\nfour\n");
+    yield* git(cwd, ["add", "."]);
+    yield* git(cwd, ["commit", "-m", "desktop files"]);
+    // Shared path segments make git abbreviate renames as `{apps/desktop => packages/core}/...`.
+    const fileSystem = yield* FileSystem.FileSystem;
+    yield* fileSystem.makeDirectory(`${cwd}/packages/core/src`, { recursive: true });
+    yield* git(cwd, ["mv", "apps/desktop/src/moved.ts", "packages/core/src/moved.ts"]);
+    yield* git(cwd, ["mv", "apps/desktop/src/edited.ts", "packages/core/src/edited.ts"]);
+    yield* writeTextFile(cwd, "packages/core/src/edited.ts", "one\ntwo\nthree\nFOUR\n");
+    yield* writeTextFile(cwd, "README.md", "# changed\n");
+    yield* writeTextFile(cwd, "staged.txt", "staged\n");
+    yield* git(cwd, ["add", "staged.txt"]);
+    yield* writeTextFile(cwd, "untracked file.txt", "new\n");
+
+    const status = yield* driver.statusDetailsLocal(cwd);
+
+    assert.deepStrictEqual(status.workingTree.files, [
+      { path: "packages/core/src/edited.ts", insertions: 1, deletions: 1 },
+      { path: "packages/core/src/moved.ts", insertions: 0, deletions: 0 },
+      { path: "README.md", insertions: 1, deletions: 1 },
+      { path: "staged.txt", insertions: 1, deletions: 0 },
+      { path: "untracked file.txt", insertions: 0, deletions: 0 },
+    ]);
+    assert.equal(status.workingTree.insertions, 3);
+    assert.equal(status.workingTree.deletions, 2);
+  }).pipe(Effect.provide(TestLayer)),
+);
+
+it.effect("lists staged and unstaged changes before the first commit", () =>
+  Effect.gen(function* () {
+    const driver = yield* GitVcsDriver.GitVcsDriver;
+    const cwd = yield* makeTmpDir();
+    yield* driver.initRepo({ cwd });
+    yield* writeTextFile(cwd, "staged.txt", "one\n");
+    yield* git(cwd, ["add", "staged.txt"]);
+    yield* writeTextFile(cwd, "staged.txt", "one\ntwo\n");
+    yield* writeTextFile(cwd, "untracked.txt", "new\n");
+
+    const status = yield* driver.statusDetailsLocal(cwd);
+
+    assert.deepStrictEqual(status.workingTree.files, [
+      { path: "staged.txt", insertions: 2, deletions: 0 },
+      { path: "untracked.txt", insertions: 0, deletions: 0 },
+    ]);
+  }).pipe(Effect.provide(TestLayer)),
+);
+
 it.effect("re-reads origin remote status after cache TTL expiry and bypassed invalidation", () =>
   Effect.gen(function* () {
     const driver = yield* GitVcsDriver.GitVcsDriver;
diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts
index 2977c67239d9..1e0fa8551527 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.ts
@@ -173,30 +173,6 @@ function parseBranchAb(value: string): { ahead: number; behind: number } {
   };
 }
 
-function parseNumstatEntries(
-  stdout: string,
-): Array<{ path: string; insertions: number; deletions: number }> {
-  const entries: Array<{ path: string; insertions: number; deletions: number }> = [];
-  for (const line of stdout.split(/\r?\n/g)) {
-    if (line.trim().length === 0) continue;
-    const [addedRaw, deletedRaw, ...pathParts] = line.split("\t");
-    const rawPath =
-      pathParts.length > 1 ? (pathParts.at(-1) ?? "").trim() : pathParts.join("\t").trim();
-    if (rawPath.length === 0) continue;
-    const added = Number.parseInt(addedRaw ?? "0", 10);
-    const deleted = Number.parseInt(deletedRaw ?? "0", 10);
-    const renameArrowIndex = rawPath.indexOf(" => ");
-    const normalizedPath =
-      renameArrowIndex >= 0 ? rawPath.slice(renameArrowIndex + " => ".length).trim() : rawPath;
-    entries.push({
-      path: normalizedPath.length > 0 ? normalizedPath : rawPath,
-      insertions: Number.isFinite(added) ? added : 0,
-      deletions: Number.isFinite(deleted) ? deleted : 0,
-    });
-  }
-  return entries;
-}
-
 // -z preserves tabs/newlines in paths and gives renames two separate path fields.
 function parseReviewNumstat(stdout: string): ReviewDiffFileStat[] {
   const fields = stdout.split("\0");
@@ -217,26 +193,21 @@ function parseReviewNumstat(stdout: string): ReviewDiffFileStat[] {
   return files;
 }
 
-function parsePorcelainPath(line: string): string | null {
-  if (line.startsWith("? ") || line.startsWith("! ")) {
-    const simple = line.slice(2).trim();
-    return simple.length > 0 ? simple : null;
-  }
+// Space-separated fields before the path in `git status --porcelain=2 -z` records.
+const PORCELAIN_V2_FIELDS_BEFORE_PATH: Record<string, number> = { "1": 8, "2": 9, u: 10 };
 
-  if (!(line.startsWith("1 ") || line.startsWith("2 ") || line.startsWith("u "))) {
-    return null;
+function parsePorcelainPath(record: string): string | null {
+  if (record.startsWith("? ") || record.startsWith("! ")) {
+    return record.length > 2 ? record.slice(2) : null;
   }
-
-  const tabIndex = line.indexOf("\t");
-  if (tabIndex >= 0) {
-    const fromTab = line.slice(tabIndex + 1);
-    const [filePath] = fromTab.split("\t");
-    return filePath?.trim().length ? filePath.trim() : null;
+  const fieldCount = PORCELAIN_V2_FIELDS_BEFORE_PATH[record.slice(0, 1)];
+  if (fieldCount === undefined || record[1] !== " ") return null;
+  let pathStart = 0;
+  for (let field = 0; field < fieldCount; field++) {
+    pathStart = record.indexOf(" ", pathStart) + 1;
+    if (pathStart === 0) return null;
   }
-
-  const parts = line.trim().split(/\s+/g);
-  const filePath = parts.at(-1) ?? "";
-  return filePath.length > 0 ? filePath : null;
+  return pathStart < record.length ? record.slice(pathStart) : null;
 }
 
 function filterBranchesForListQuery(
@@ -1703,6 +1674,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     const statusArgs = [
       "status",
       "--porcelain=2",
+      "-z",
       "--branch",
       ...(includeDivergence ? [] : ["--no-ahead-behind"]),
     ];
@@ -1781,46 +1753,35 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       Effect.catchTags({ GitCommandError: () => Effect.succeed(null) }),
     );
     const statusCacheKey = repositoryPaths?.gitCommonDir;
-    const [numstatStdout, defaultBranch, hasPrimaryRemote] = yield* Effect.all(
+    const [numstatEntries, defaultBranch, hasPrimaryRemote] = yield* Effect.all(
       [
         executeGitWithStableDiagnostics(
           "GitVcsDriver.statusDetails.numstat",
           cwd,
-          ["diff", "HEAD", "--numstat", "--"],
+          ["diff", "HEAD", "--numstat", "-z", "--"],
           { allowNonZeroExit: true },
         ).pipe(
           Effect.flatMap((result) => {
-            if (result.exitCode === 0) return Effect.succeed(result.stdout);
+            if (result.exitCode === 0) return Effect.succeed(parseReviewNumstat(result.stdout));
             if (isUnbornHeadStderr(result.stderr)) {
               return Effect.map(
                 Effect.all([
                   runGitStdout("GitVcsDriver.statusDetails.numstat.unborn", cwd, [
                     "diff",
                     "--numstat",
+                    "-z",
                   ]),
                   runGitStdout("GitVcsDriver.statusDetails.numstat.unborn.staged", cwd, [
                     "diff",
                     "--cached",
                     "--numstat",
+                    "-z",
                   ]),
                 ]),
-                ([unstagedStdout, stagedStdout]) => {
-                  const staged = parseNumstatEntries(stagedStdout);
-                  const unstaged = parseNumstatEntries(unstagedStdout);
-                  const map = new Map<string, { insertions: number; deletions: number }>();
-                  for (const entry of [...staged, ...unstaged]) {
-                    const existing = map.get(entry.path) ?? {
-                      insertions: 0,
-                      deletions: 0,
-                    };
-                    existing.insertions += entry.insertions;
-                    existing.deletions += entry.deletions;
-                    map.set(entry.path, existing);
-                  }
-                  return Array.from(map.entries())
-                    .map(([p, s]) => `${s.insertions}\t${s.deletions}\t${p}`)
-                    .join("\n");
-                },
+                ([unstagedStdout, stagedStdout]) => [
+                  ...parseReviewNumstat(stagedStdout),
+                  ...parseReviewNumstat(unstagedStdout),
+                ],
               );
             }
             return Effect.fail(
@@ -1828,7 +1789,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
                 ...gitCommandContext({
                   operation: "GitVcsDriver.statusDetails.numstat",
                   cwd,
-                  args: ["diff", "HEAD", "--numstat", "--"],
+                  args: ["diff", "HEAD", "--numstat", "-z", "--"],
                 }),
                 detail: "git diff HEAD --numstat failed.",
                 exitCode: result.exitCode,
@@ -1857,7 +1818,11 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     let hasWorkingTreeChanges = false;
     const changedFilesWithoutNumstat = new Set<string>();
 
-    for (const line of statusStdout.split(/\r?\n/g)) {
+    // -z keeps paths unquoted; a rename record is followed by a record holding its old path.
+    const statusRecords = statusStdout.split("\0");
+    for (let index = 0; index < statusRecords.length; index++) {
+      const line = statusRecords[index]!;
+      if (line.startsWith("2 ")) index++;
       if (line.startsWith("# branch.head ")) {
         const value = line.slice("# branch.head ".length).trim();
         refName = value.startsWith("(") ? null : value;
@@ -1903,10 +1868,13 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
           : yield* computeAheadCountAgainstBase(cwd, refName).pipe(Effect.orElseSucceed(() => 0));
     }
 
-    const numstatEntries = parseNumstatEntries(numstatStdout);
     const fileStatMap = new Map<string, { insertions: number; deletions: number }>();
     for (const entry of numstatEntries) {
-      fileStatMap.set(entry.path, { insertions: entry.insertions, deletions: entry.deletions });
+      const existing = fileStatMap.get(entry.path) ?? { insertions: 0, deletions: 0 };
+      fileStatMap.set(entry.path, {
+        insertions: existing.insertions + entry.additions,
+        deletions: existing.deletions + entry.deletions,
+      });
     }
 
     let insertions = 0;
diff --git a/apps/server/src/workspace/LspLanguageBackend.ts b/apps/server/src/workspace/LspLanguageBackend.ts
index 4a5c17c78d31..8ea242327119 100644
--- a/apps/server/src/workspace/LspLanguageBackend.ts
+++ b/apps/server/src/workspace/LspLanguageBackend.ts
@@ -33,9 +33,12 @@ import {
   hoverMarkdown,
 } from "./lspSchemas.ts";
 
+// Build scripts and proc macros stay on, as in VS Code: without them derives such as
+// serde's resolve to nothing and report false errors. The editor never sends didSave,
+// so cargo check on save would never run.
 const rustSettings = {
-  cargo: { buildScripts: { enable: false } },
-  procMacro: { enable: false },
+  cargo: { buildScripts: { enable: true } },
+  procMacro: { enable: true },
   checkOnSave: false,
   completion: { autoimport: { enable: false } },
 };
diff --git a/apps/server/src/workspace/TypeScriptSession.ts b/apps/server/src/workspace/TypeScriptSession.ts
index 3b9e698eaef0..f906519b7542 100644
--- a/apps/server/src/workspace/TypeScriptSession.ts
+++ b/apps/server/src/workspace/TypeScriptSession.ts
@@ -3,6 +3,7 @@
 import * as NodeChildProcess from "node:child_process";
 import * as NodeModule from "node:module";
 import * as Schema from "effect/Schema";
+import { nodeScriptCommand } from "../nodeScript.ts";
 
 const Response = Schema.Struct({
   type: Schema.String,
@@ -35,16 +36,16 @@ export class TypeScriptSession {
     const tsserver = NodeModule.createRequire(import.meta.url).resolve(
       "typescript-tsserver/lib/tsserver.js",
     );
-    this.child = NodeChildProcess.spawn(
-      process.execPath,
-      [tsserver, "--disableAutomaticTypingAcquisition", "--noGetErrOnBackgroundUpdate"],
-      {
-        cwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", NODE_OPTIONS: "", TSS_LOG: "" },
-      },
-    );
+    const launch = nodeScriptCommand(tsserver, [
+      "--disableAutomaticTypingAcquisition",
+      "--noGetErrOnBackgroundUpdate",
+    ]);
+    this.child = NodeChildProcess.spawn(launch.command, launch.args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", NODE_OPTIONS: "", TSS_LOG: "" },
+    });
     this.child.stdout.on("data", (chunk: Buffer) => this.receive(chunk));
     this.child.stderr.resume();
     this.child.on("error", (error) => this.dispose(error));
diff --git a/apps/server/src/workspace/WorkspaceLanguageService.ts b/apps/server/src/workspace/WorkspaceLanguageService.ts
index a770ff1c049d..b3b9aa3881af 100644
--- a/apps/server/src/workspace/WorkspaceLanguageService.ts
+++ b/apps/server/src/workspace/WorkspaceLanguageService.ts
@@ -20,6 +20,7 @@ import {
   languageServerLaunch,
   launchKey,
   LSP_SERVERS,
+  prepareLanguageServerLaunch,
   type LanguageServerLaunch,
 } from "./languageServers.ts";
 
@@ -34,6 +35,15 @@ interface Target {
 const launchFor = (kind: CodeIntelligenceServerId, settings: CodeIntelligenceSettings) =>
   kind === "typescript" || kind === "json" ? null : languageServerLaunch(kind, settings);
 const keyOf = (launch: LanguageServerLaunch | null) => (launch ? launchKey(launch) : null);
+/** Installs or locates a missing default server; the session keeps the unprepared launch as its key. */
+const prepare = async (
+  kind: CodeIntelligenceServerId,
+  launch: LanguageServerLaunch | null,
+  { root, file }: Pick<Target, "root" | "file">,
+) =>
+  launch && kind !== "typescript" && kind !== "json"
+    ? prepareLanguageServerLaunch(kind, launch, root, file)
+    : launch;
 
 function createBackend(
   { root, file, language }: Target,
@@ -100,14 +110,15 @@ export class WorkspaceLanguageService {
       const target = await this.resolve(input);
       const kind = codeIntelligenceServerForLanguage(target.language);
       assertEnabled(kind, settings);
+      const launch = launchFor(kind, settings);
+      const prepared = await prepare(kind, launch, target);
       // Recheck after filesystem awaits; simultaneous opens must not orphan a process.
       session = this.sessions.get(input.sessionId);
       if (!session) {
         if (this.sessions.size >= 4)
           throw new Error("Too many active code editors. Close an editor and retry.");
-        const launch = launchFor(kind, settings);
         session = {
-          server: createBackend(target, launch),
+          server: createBackend(target, prepared),
           kind,
           launch,
           cwd: input.cwd,
@@ -148,13 +159,10 @@ export class WorkspaceLanguageService {
       await this.synchronize(current, input);
       if (input.operation === "refresh" && codeLanguageForPath(current.file) === "protobuf") {
         // Buf caches imported files for the process lifetime. Reload only on workspace changes.
+        const root = await NodeFSP.realpath(current.cwd);
+        const launch = await prepare("protobuf", current.launch, { root, file: current.file });
         current.server.dispose();
-        current.server = new LspLanguageBackend(
-          await NodeFSP.realpath(current.cwd),
-          current.file,
-          "protobuf",
-          current.launch!,
-        );
+        current.server = new LspLanguageBackend(root, current.file, "protobuf", launch!);
         await current.server.update(current.contents, current.version);
       }
       return current.server.query(input);
@@ -204,8 +212,9 @@ export class WorkspaceLanguageService {
     ) {
       await session.server.retarget(target.file);
     } else {
+      const prepared = await prepare(kind, launch, target);
       session.server.dispose();
-      session.server = createBackend(target, launch);
+      session.server = createBackend(target, prepared);
     }
     session.launch = launch;
     session.kind = kind;
diff --git a/apps/server/src/workspace/languageServers.test.ts b/apps/server/src/workspace/languageServers.test.ts
index 049a27b122c8..e26f84e18ef0 100644
--- a/apps/server/src/workspace/languageServers.test.ts
+++ b/apps/server/src/workspace/languageServers.test.ts
@@ -3,7 +3,11 @@ import * as NodeFSP from "node:fs/promises";
 import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
-import { languageServerStatuses } from "./languageServers.ts";
+import {
+  languageServerLaunch,
+  languageServerStatuses,
+  prepareLanguageServerLaunch,
+} from "./languageServers.ts";
 import { WorkspaceLanguageService } from "./WorkspaceLanguageService.ts";
 
 describe("language server settings", () => {
@@ -75,4 +79,71 @@ describe("language server settings", () => {
     const second = NodePath.join(cwd, "second-buf");
     await expect(request({ protobuf: { command: second } })).rejects.toThrow(second);
   });
+
+  describe("missing default servers", () => {
+    const originalPath = process.env.PATH;
+    let bin: string;
+    beforeEach(async () => {
+      bin = NodePath.join(cwd, "bin");
+      await NodeFSP.mkdir(bin);
+      process.env.PATH = [bin, "/usr/bin", "/bin"].join(NodePath.delimiter);
+    });
+    afterEach(() => {
+      process.env.PATH = originalPath;
+    });
+
+    it("installs rust-analyzer and rust-src once with the workspace's rustup", async () => {
+      const sysroot = NodePath.join(cwd, "sysroot");
+      const log = NodePath.join(cwd, "rustup.log");
+      await NodeFSP.writeFile(
+        NodePath.join(bin, "rustup"),
+        `#!/bin/sh
+echo "$PWD $*" >> ${log}
+case "$1" in
+  which) [ -f ${sysroot}/analyzer ] && echo ${sysroot}/analyzer || exit 1 ;;
+  component) touch ${sysroot}/analyzer && mkdir -p ${sysroot}/lib/rustlib/src/rust/library ;;
+esac
+`,
+        { mode: 0o755 },
+      );
+      await NodeFSP.writeFile(NodePath.join(bin, "rustc"), `#!/bin/sh\necho ${sysroot}\n`, {
+        mode: 0o755,
+      });
+      await NodeFSP.mkdir(sysroot);
+      const workspace = NodePath.join(cwd, "workspace");
+      await NodeFSP.mkdir(workspace);
+      const launch = languageServerLaunch("rust", {});
+      const file = NodePath.join(workspace, "main.rs");
+
+      expect(await prepareLanguageServerLaunch("rust", launch, workspace, file)).toEqual(launch);
+      await prepareLanguageServerLaunch("rust", launch, workspace, file);
+
+      const calls = (await NodeFSP.readFile(log, "utf8")).trim().split("\n");
+      expect(calls).toEqual([
+        `${workspace} which rust-analyzer`,
+        `${workspace} component add rust-analyzer rust-src`,
+      ]);
+    });
+
+    it("leaves a configured Rust command alone", async () => {
+      const launch = languageServerLaunch("rust", { rust: { command: "/opt/rust-analyzer" } });
+      await NodeFSP.writeFile(NodePath.join(bin, "rustup"), "#!/bin/sh\nexit 1\n", {
+        mode: 0o755,
+      });
+      expect(await prepareLanguageServerLaunch("rust", launch, cwd, cwd)).toBe(launch);
+    });
+
+    it("uses the workspace's own Buf when none is on PATH", async () => {
+      const buf = NodePath.join(cwd, "node_modules", ".bin", "buf");
+      await NodeFSP.mkdir(NodePath.dirname(buf), { recursive: true });
+      await NodeFSP.writeFile(buf, "#!/bin/sh\n", { mode: 0o755 });
+      const file = NodePath.join(cwd, "proto", "api", "v1", "service.proto");
+      const launch = languageServerLaunch("protobuf", {});
+
+      expect(await prepareLanguageServerLaunch("protobuf", launch, cwd, file)).toEqual({
+        ...launch,
+        command: buf,
+      });
+    });
+  });
 });
diff --git a/apps/server/src/workspace/languageServers.ts b/apps/server/src/workspace/languageServers.ts
index 0a3963e9afb3..224de1696376 100644
--- a/apps/server/src/workspace/languageServers.ts
+++ b/apps/server/src/workspace/languageServers.ts
@@ -9,6 +9,7 @@ import type {
   CodeIntelligenceSettings,
   LanguageServerStatus,
 } from "@t3tools/contracts";
+import { nodeScriptCommand } from "../nodeScript.ts";
 
 export type LspServerId = Exclude<CodeIntelligenceServerId, "typescript" | "json">;
 
@@ -32,7 +33,8 @@ export const LSP_SERVERS = {
     envVar: "T3CODE_RUST_ANALYZER_PATH",
     args: [],
     tabSize: 4,
-    installHint: "Install it with rustup component add rust-analyzer rust-src.",
+    installHint:
+      "With rustup, it installs automatically when you open a Rust file. Otherwise install rust-analyzer.",
   },
   protobuf: {
     name: "Buf",
@@ -42,7 +44,8 @@ export const LSP_SERVERS = {
     envVar: "T3CODE_BUF_PATH",
     args: ["lsp", "serve"],
     tabSize: 2,
-    installHint: "Install the Buf CLI from buf.build/docs/installation.",
+    installHint:
+      "Uses the workspace's @bufbuild/buf when installed. Otherwise install the Buf CLI from buf.build/docs/installation.",
   },
 } satisfies Record<LspServerId, unknown>;
 
@@ -88,10 +91,97 @@ export function languageServerLaunch(
   const command = settings[id]?.command?.trim() || process.env[server.envVar]?.trim();
   if (command) return { command, args: server.args, builtIn: false };
   const script = id === "python" ? bundledPyright() : null;
-  if (script) return { command: process.execPath, args: [script, ...server.args], builtIn: true };
+  if (script) return { ...nodeScriptCommand(script, server.args), builtIn: true };
   return { command: server.defaultCommand, args: server.args, builtIn: false };
 }
 
+/**
+ * Gets a missing default server ready for one workspace, the way the VS Code extensions do,
+ * so opening a file just works. rust-analyzer and the standard-library sources come from the
+ * workspace's rustup toolchain; Buf comes from the workspace's own node_modules.
+ */
+export async function prepareLanguageServerLaunch(
+  id: LspServerId,
+  launch: LanguageServerLaunch,
+  root: string,
+  file: string,
+): Promise<LanguageServerLaunch> {
+  if (launch.builtIn || launch.command !== LSP_SERVERS[id].defaultCommand) return launch;
+  if (id === "rust") await ensureRustComponents(root);
+  if (id === "protobuf" && !(await resolveCommand(launch.command))) {
+    const local = await workspaceBinary(root, file, launch.command);
+    if (local) return { ...launch, command: local };
+  }
+  return launch;
+}
+
+/** The nearest node_modules/.bin/<command> from the file's directory up to the workspace root. */
+async function workspaceBinary(root: string, file: string, command: string) {
+  for (let directory = NodePath.dirname(file); ; directory = NodePath.dirname(directory)) {
+    const found = await resolveCommand(NodePath.join(directory, "node_modules", ".bin", command));
+    if (found) return found;
+    if (directory === root || NodePath.dirname(directory) === directory) return null;
+  }
+}
+
+const isDirectory = (path: string) =>
+  NodeFSP.stat(path).then(
+    (stats) => stats.isDirectory(),
+    () => false,
+  );
+
+const rustInstalls = new Map<string, Promise<void>>();
+
+/** Adds rust-analyzer and rust-src to the toolchain rustup picks for this workspace. */
+function ensureRustComponents(root: string): Promise<void> {
+  const running = rustInstalls.get(root);
+  if (running) return running;
+  const install = (async () => {
+    if (!(await resolveCommand("rustup"))) return;
+    const missing: string[] = [];
+    if (!(await run("rustup", ["which", "rust-analyzer"], root, 10_000)).ok)
+      missing.push("rust-analyzer");
+    const sysroot = await run("rustc", ["--print", "sysroot"], root, 10_000);
+    const sources = sysroot.ok
+      ? NodePath.join(sysroot.output, "lib", "rustlib", "src", "rust", "library")
+      : null;
+    const hasSources = sources !== null && (await isDirectory(sources));
+    if (!hasSources) missing.push("rust-src");
+    if (missing.length === 0) return;
+    const added = await run("rustup", ["component", "add", ...missing], root, 10 * 60_000);
+    if (!added.ok)
+      throw new Error(
+        `Could not install ${missing.join(" and ")} with rustup: ${added.output} Run rustup component add ${missing.join(" ")} in the workspace, then Retry.`,
+      );
+  })();
+  rustInstalls.set(root, install);
+  // A success is remembered for the server's lifetime; a failure is retried on the next open.
+  install.catch(() => rustInstalls.delete(root));
+  return install;
+}
+
+/** Trimmed stdout when the command succeeds in time, otherwise the tail of its stderr. */
+function run(
+  command: string,
+  args: ReadonlyArray<string>,
+  cwd: string,
+  timeout: number,
+): Promise<{ ok: boolean; output: string }> {
+  return new Promise((resolve) => {
+    NodeChildProcess.execFile(
+      command,
+      [...args],
+      { cwd, timeout, windowsHide: true },
+      (error, stdout, stderr) =>
+        resolve(
+          error
+            ? { ok: false, output: (stderr.trim() || error.message).slice(-500) }
+            : { ok: true, output: stdout.trim() },
+        ),
+    );
+  });
+}
+
 /** Identifies a launch, so a session restarts when Settings change what would run. */
 export const launchKey = (launch: LanguageServerLaunch) =>
   [launch.command, ...launch.args].join("\0");
diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsx
index e11982e6fa1b..dec2f3c2156d 100644
--- a/apps/web/src/components/DiffPanel.tsx
+++ b/apps/web/src/components/DiffPanel.tsx
@@ -353,8 +353,23 @@ export default function DiffPanel({
         })
       : null,
   );
+  const refreshVcsStatus = useAtomCommand(vcsEnvironment.refreshStatus, {
+    reportFailure: false,
+  });
   const refreshPreviewQuery = branchDiffPreview.refresh;
-  const refreshDiffFromUserAction = refreshPreviewQuery;
+  const refreshBranchCommits = branchCommits.refresh;
+  const statusEnvironmentId = activeThread?.environmentId ?? null;
+  // Git status is cached server-side and only refreshed on focus or at turn end, so the scope
+  // menu's counts go stale when files change outside a turn. Refresh them when they are looked at.
+  const refreshScopeCounts = useCallback(() => {
+    if (statusEnvironmentId === null || !activeCwd) return;
+    void refreshVcsStatus({ environmentId: statusEnvironmentId, input: { cwd: activeCwd } });
+    refreshBranchCommits();
+  }, [activeCwd, refreshBranchCommits, refreshVcsStatus, statusEnvironmentId]);
+  const refreshDiffFromUserAction = useCallback(() => {
+    refreshPreviewQuery();
+    refreshScopeCounts();
+  }, [refreshPreviewQuery, refreshScopeCounts]);
 
   const currentLoadDiffFiles = useMemo<FileDiffContentsLoader | undefined>(() => {
     const preview = branchDiffPreview.data;
@@ -844,11 +859,17 @@ export default function DiffPanel({
               selected={selectedScopeChoice}
               label={scopeMenuLabel}
               title={scopeMenuTitle}
+              allFileCount={
+                selectedScopeChoice.kind === "branch" && selectedGitSource?.kind === "all"
+                  ? (selectedGitSource.files?.length ?? null)
+                  : null
+              }
               uncommittedFileCount={gitStatusQuery.data?.workingTree.files.length ?? null}
               commits={branchCommits.data?.commits ?? []}
               commitsTruncated={branchCommits.data?.truncated ?? false}
               turns={scopeMenuTurns}
               onSelect={selectScope}
+              onOpen={refreshScopeCounts}
               targetBranchPicker={
                 previewCwd && !selectedTurn ? (
                   <DiffTargetBranchPicker
diff --git a/apps/web/src/components/chat/DiffStatLabel.tsx b/apps/web/src/components/chat/DiffStatLabel.tsx
index a4110afe8a23..ae117a3f6915 100644
--- a/apps/web/src/components/chat/DiffStatLabel.tsx
+++ b/apps/web/src/components/chat/DiffStatLabel.tsx
@@ -40,12 +40,17 @@ export const DiffStatLabel = memo(function DiffStatLabel(props: {
           className,
         )}
       >
-        <span aria-hidden="true" className="font-mono text-diff-addition">
-          +{formatCompactDiffCount(additions)}
-        </span>
-        <span aria-hidden="true" className="font-mono text-diff-deletion">
-          -{formatCompactDiffCount(deletions)}
-        </span>
+        {/* A zero side is left blank; aligned rows keep the empty cell so columns line up. */}
+        {additions > 0 || layout === "aligned" ? (
+          <span aria-hidden="true" className="font-mono text-diff-addition">
+            {additions > 0 ? `+${formatCompactDiffCount(additions)}` : null}
+          </span>
+        ) : null}
+        {deletions > 0 || layout === "aligned" ? (
+          <span aria-hidden="true" className="font-mono text-diff-deletion">
+            {deletions > 0 ? `-${formatCompactDiffCount(deletions)}` : null}
+          </span>
+        ) : null}
       </span>
       {showParentheses && <span className="text-muted-foreground/70">)</span>}
     </>
diff --git a/apps/web/src/components/diffs/DiffScopeMenu.tsx b/apps/web/src/components/diffs/DiffScopeMenu.tsx
index d981a1023959..67e1ab1d3a57 100644
--- a/apps/web/src/components/diffs/DiffScopeMenu.tsx
+++ b/apps/web/src/components/diffs/DiffScopeMenu.tsx
@@ -48,6 +48,12 @@ function ScopeOption(props: {
   );
 }
 
+function fileCountDetail(count: number | null, emptyLabel: string): string | null {
+  if (count === null) return null;
+  if (count === 0) return emptyLabel;
+  return `${count} ${count === 1 ? "file" : "files"} changed`;
+}
+
 function SectionLabel(props: { readonly children: ReactNode }) {
   return (
     <div className="px-2.5 pt-2 pb-1 text-2xs font-medium text-muted-foreground">
@@ -66,6 +72,8 @@ export function DiffScopeMenu(props: {
   readonly label: string;
   /** Full scope name, e.g. a commit subject, for the trigger's tooltip. */
   readonly title: string;
+  /** Known only while the "All changes" scope is loaded; null hides the count. */
+  readonly allFileCount: number | null;
   readonly uncommittedFileCount: number | null;
   readonly commits: ReadonlyArray<ReviewCommit>;
   readonly commitsTruncated: boolean;
@@ -73,20 +81,20 @@ export function DiffScopeMenu(props: {
   /** Shown at the top while it applies; turns are read from checkpoints, not a branch. */
   readonly targetBranchPicker: ReactNode;
   readonly onSelect: (choice: DiffScopeChoice) => void;
+  /** Called when the menu opens, so the counts it shows can be refreshed. */
+  readonly onOpen: () => void;
 }) {
-  const [open, setOpen] = useState(false);
+  const [open, setOpenState] = useState(false);
+  const setOpen = (next: boolean) => {
+    if (next && !open) props.onOpen();
+    setOpenState(next);
+  };
   const { timestampFormat } = useClientSettings();
   const { selected } = props;
   const select = (choice: DiffScopeChoice) => {
     props.onSelect(choice);
     setOpen(false);
   };
-  const uncommittedDetail =
-    props.uncommittedFileCount === null
-      ? null
-      : props.uncommittedFileCount === 0
-        ? "No uncommitted changes"
-        : `${props.uncommittedFileCount} ${props.uncommittedFileCount === 1 ? "file" : "files"} changed`;
 
   return (
     <Popover open={open} onOpenChange={setOpen}>
@@ -130,12 +138,13 @@ export function DiffScopeMenu(props: {
               selected={selected.kind === "branch"}
               onSelect={() => select({ kind: "branch" })}
               title="All changes"
+              detail={fileCountDetail(props.allFileCount, "No changes")}
             />
             <ScopeOption
               selected={selected.kind === "unstaged"}
               onSelect={() => select({ kind: "unstaged" })}
               title="Uncommitted changes"
-              detail={uncommittedDetail}
+              detail={fileCountDetail(props.uncommittedFileCount, "No uncommitted changes")}
             />
             {props.commits.length > 0 ? (
               <>
diff --git a/docs/user/composer.md b/docs/user/composer.md
index b4f249627eae..af80702d494e 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -282,9 +282,10 @@ Shift+F12 to find references. In the editor you also get completions (Ctrl+Space
 signature help, and formatting (Shift+Alt+F), and the back and forward buttons return you
 through the places you jumped to.
 
-TypeScript, JavaScript, JSON, and Python work without installing anything. Rust and
-Protobuf use rust-analyzer and the Buf CLI when they are installed on the environment's
-machine. In **Settings → Code Intelligence** you can see which language servers each
+TypeScript, JavaScript, JSON, and Python work without installing anything. For Rust, the
+first Rust file you open installs rust-analyzer and the standard-library sources with the
+project's rustup toolchain; without rustup, install rust-analyzer yourself. Protobuf uses
+the Buf CLI, from the project's own `@bufbuild/buf` package or the environment's machine. In **Settings → Code Intelligence** you can see which language servers each
 environment found, turn a language off, or point one at a specific command.
 
 Diffs show intelligence for the current version of each file. Lines that no longer match
diff --git a/scripts/build-desktop-artifact.test.ts b/scripts/build-desktop-artifact.test.ts
index 097ead078145..668664e63213 100644
--- a/scripts/build-desktop-artifact.test.ts
+++ b/scripts/build-desktop-artifact.test.ts
@@ -78,6 +78,11 @@ import {
   WindowsPackagedPayloadValidationError,
   WINDOWS_NATIVE_ASAR_UNPACK_GLOB,
   stageCursorSdkPlatformPackages,
+  stageTypeScriptServerPackage,
+  TSSERVER_EXTRA_RESOURCES,
+  TSSERVER_FILE_EXCLUSIONS,
+  TSSERVER_RESOURCE_SOURCE_DIR,
+  TypeScriptServerLibMissingError,
   WINDOWS_PACKAGED_PAYLOAD_FILE_LIMIT,
   WINDOWS_SERVER_ASAR_IGNORE_GLOBS,
   WINDOWS_SERVER_EXTRA_RESOURCES,
@@ -638,9 +643,13 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
       assert.deepStrictEqual(win.asarUnpack, [WINDOWS_NATIVE_ASAR_UNPACK_GLOB]);
       assert.deepStrictEqual(winWithoutWslRuntime.asar, win.asar);
       assert.deepStrictEqual(winWithoutWslRuntime.asarUnpack, win.asarUnpack);
-      assert.deepStrictEqual(mac.extraResources, DESKTOP_EXTRA_RESOURCES);
+      assert.deepStrictEqual(mac.extraResources, [
+        ...DESKTOP_EXTRA_RESOURCES,
+        ...TSSERVER_EXTRA_RESOURCES,
+      ]);
       assert.deepStrictEqual(linux.extraResources, [
         ...DESKTOP_EXTRA_RESOURCES,
+        ...TSSERVER_EXTRA_RESOURCES,
         ...LINUX_CAPTURE_EXTRA_RESOURCES,
         { from: "apps/desktop/prod-resources/browser-secret", to: "browser-secret" },
       ]);
@@ -698,6 +707,7 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
 
   it("excludes foreign node-pty prebuilds from macOS and Linux packages", () => {
     assert.deepStrictEqual(MAC_FILE_EXCLUSIONS, [
+      ...TSSERVER_FILE_EXCLUSIONS,
       "!**/node_modules/node-pty/prebuilds/win32-*/**/*",
       "!**/node_modules/node-pty/third_party/conpty/**/*",
     ]);
@@ -834,6 +844,41 @@ it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
     ),
   );
 
+  it.effect("ships tsserver with its standard library outside asar", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-tsserver-" });
+        const nodeModules = path.join(root, "node_modules");
+        const packageDir = path.join(nodeModules, "typescript-tsserver");
+        yield* fs.makeDirectory(path.join(packageDir, "lib"), { recursive: true });
+        yield* fs.writeFileString(path.join(packageDir, "lib/tsserver.js"), "");
+
+        const destination = path.join(root, TSSERVER_RESOURCE_SOURCE_DIR);
+        const missing = yield* Effect.flip(stageTypeScriptServerPackage(nodeModules, destination));
+        assert.instanceOf(missing, TypeScriptServerLibMissingError);
+
+        yield* fs.writeFileString(path.join(packageDir, "lib/lib.es5.d.ts"), "interface Set {}");
+        yield* stageTypeScriptServerPackage(nodeModules, destination);
+        assert.equal(
+          yield* fs.readFileString(path.join(destination, "lib/lib.es5.d.ts")),
+          "interface Set {}",
+        );
+        for (const packagedPath of [
+          "node_modules/typescript-tsserver/lib/tsserver.js",
+          `${TSSERVER_RESOURCE_SOURCE_DIR}/lib/lib.es5.d.ts`,
+        ]) {
+          assert.isTrue(
+            TSSERVER_FILE_EXCLUSIONS.some((glob) =>
+              NodePath.matchesGlob(packagedPath, glob.slice(1)),
+            ),
+          );
+        }
+      }),
+    ),
+  );
+
   it("excludes node-pty binaries for the other Windows architecture", () => {
     assert.deepStrictEqual(resolveWindowsServerAsarIgnoreGlobs("x64"), [
       ...WINDOWS_SERVER_ASAR_IGNORE_GLOBS,
diff --git a/scripts/build-desktop-artifact.ts b/scripts/build-desktop-artifact.ts
index daa312b22e3c..1ff1eb759ce1 100644
--- a/scripts/build-desktop-artifact.ts
+++ b/scripts/build-desktop-artifact.ts
@@ -667,6 +667,17 @@ export class DesktopBuildNoArtifactsProducedError extends Schema.TaggedError<Des
   }
 }
 
+export class TypeScriptServerLibMissingError extends Schema.TaggedError<TypeScriptServerLibMissingError>()(
+  "TypeScriptServerLibMissingError",
+  {
+    packagePath: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `typescript-tsserver at ${this.packagePath} has no lib.*.d.ts files; tsserver would run without the standard library.`;
+  }
+}
+
 export class WslRuntimeArchiveMissingError extends Schema.TaggedError<WslRuntimeArchiveMissingError>()(
   "WslRuntimeArchiveMissingError",
   {
@@ -969,8 +980,23 @@ export const DESKTOP_FILE_EXCLUSIONS = [
   "!apps/desktop/gnome-extension",
   "!apps/desktop/gnome-extension/**/*",
 ] as const;
+// electron-builder drops every *.d.ts below node_modules from app.asar, which
+// strips TypeScript's standard library (lib.*.d.ts) and leaves tsserver unable
+// to type `Set` or `string`. Mac and Linux ship the package as loose files in
+// resources/node_modules instead, where Node resolution from app.asar finds it.
+// Windows runs tsserver from server.asar, which is packed by hand and keeps them.
+export const TSSERVER_RESOURCE_SOURCE_DIR = "apps/desktop/prod-resources/typescript-tsserver";
+export const TSSERVER_FILE_EXCLUSIONS = [
+  "!**/node_modules/typescript-tsserver/**/*",
+  `!${TSSERVER_RESOURCE_SOURCE_DIR}`,
+  `!${TSSERVER_RESOURCE_SOURCE_DIR}/**/*`,
+] as const;
+export const TSSERVER_EXTRA_RESOURCES = [
+  { from: TSSERVER_RESOURCE_SOURCE_DIR, to: "node_modules/typescript-tsserver" },
+] as const;
 // Windows terminal helpers cannot run on macOS and slow signing and notarization.
 export const MAC_FILE_EXCLUSIONS = [
+  ...TSSERVER_FILE_EXCLUSIONS,
   "!**/node_modules/node-pty/prebuilds/win32-*/**/*",
   "!**/node_modules/node-pty/third_party/conpty/**/*",
 ] as const;
@@ -1378,6 +1404,22 @@ export const stageCursorSdkPlatformPackages = Effect.fn("stageCursorSdkPlatformP
   },
 );
 
+export const stageTypeScriptServerPackage = Effect.fn("stageTypeScriptServerPackage")(function* (
+  nodeModulesDir: string,
+  destination: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const source = yield* fs.realPath(path.join(nodeModulesDir, "typescript-tsserver"));
+  const libFiles = (yield* fs.readDirectory(path.join(source, "lib"))).filter((name) =>
+    /^lib\..*\.d\.ts$/.test(name),
+  );
+  if (libFiles.length === 0) {
+    return yield* new TypeScriptServerLibMissingError({ packagePath: source });
+  }
+  yield* fs.copy(source, destination);
+});
+
 export interface ClerkPasskeyNativeArtifact {
   readonly packageName: string;
   readonly binaryFileName: string;
@@ -2692,6 +2734,7 @@ export const createBuildConfig = Effect.fn("createBuildConfig")(function* (
       : {}),
     extraResources: [
       ...DESKTOP_EXTRA_RESOURCES,
+      ...(platform === "win" ? [] : TSSERVER_EXTRA_RESOURCES),
       ...(platform === "linux" ? LINUX_CAPTURE_EXTRA_RESOURCES : []),
       ...(platform === "linux" ? LINUX_BROWSER_SECRET_EXTRA_RESOURCES : []),
       ...(platform === "win" ? WINDOWS_SERVER_EXTRA_RESOURCES : []),
@@ -3782,6 +3825,12 @@ const buildDesktopArtifact = Effect.fn("buildDesktopArtifact")(function* (
     ),
     path.join(stageProdResourcesDir, "cursor-sdk"),
   );
+  if (options.platform !== "win") {
+    yield* stageTypeScriptServerPackage(
+      path.join(stageAppDir, "node_modules"),
+      path.join(stageAppDir, TSSERVER_RESOURCE_SOURCE_DIR),
+    );
+  }
   if (
     options.wslRuntime !== undefined &&
     bundlesWslRuntime({ platform: options.platform, runtimeArchivePath: options.wslRuntime })