From 04db010ef194407574cc47cd410fd4fc67f5ec7b Mon Sep 17 00:00:00 2001
From: Christophe Kafrouni <44137603+ckafrouni@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:34:08 +0200
Subject: [PATCH 1/2] fix: code intelligence works on every runtime and sets up
 its own language servers (#11)

* fix(desktop): TypeScript code intelligence loads the standard library

electron-builder drops every *.d.ts under node_modules from app.asar, so the
packaged tsserver had no lib.*.d.ts files and reported errors for built-ins
like Set, Error, and string methods. macOS and Linux now ship
typescript-tsserver as loose files in resources/node_modules, which Node
resolution from app.asar still finds, and the build fails if the staged
package has no standard library files.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(server): TypeScript and Python code intelligence start on the standalone runtime

The standalone t3 runtime is a Node single executable, which always runs its
embedded entry and ignores a script argument. Spawning
`process.execPath tsserver.js` there printed the CLI help and exited, so every
TypeScript request failed with "TypeScript language service stopped", and the
bundled Pyright could not start either. Bundled language servers now launch
through a `t3 __run-node-script` fast path when running as a single
executable, which loads the script with createRequire; Node and Electron keep
running the script directly.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* feat(server): Rust and Protobuf code intelligence set themselves up

Opening a Rust file failed until rust-analyzer was installed by hand, and
rustup's placeholder binary only reported that the component was missing.
The first Rust file in a workspace now adds rust-analyzer and rust-src to the
toolchain rustup picks for it, once per workspace, and the request waits for
that instead of failing. Protobuf falls back to the nearest
node_modules/.bin/buf when Buf is not on PATH. Commands set in Settings are
never touched.

rust-analyzer also runs with build scripts and proc macros on, as in VS Code,
so derives no longer resolve to nothing.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/server/src/bin.ts                        |  6 +-
 apps/server/src/nodeScript.test.ts            | 35 +++++++
 apps/server/src/nodeScript.ts                 | 23 +++++
 .../src/workspace/LspLanguageBackend.ts       |  7 +-
 .../server/src/workspace/TypeScriptSession.ts | 21 ++--
 .../src/workspace/WorkspaceLanguageService.ts | 27 ++++--
 .../src/workspace/languageServers.test.ts     | 73 +++++++++++++-
 apps/server/src/workspace/languageServers.ts  | 96 ++++++++++++++++++-
 docs/user/composer.md                         |  7 +-
 scripts/build-desktop-artifact.test.ts        | 47 ++++++++-
 scripts/build-desktop-artifact.ts             | 49 ++++++++++
 11 files changed, 361 insertions(+), 30 deletions(-)
 create mode 100644 apps/server/src/nodeScript.test.ts
 create mode 100644 apps/server/src/nodeScript.ts

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/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/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 })

From a6b63f66299a49c8e2a4578f9819cc3f2b31850b Mon Sep 17 00:00:00 2001
From: Christophe Kafrouni <44137603+ckafrouni@users.noreply.github.com>
Date: Mon, 28 Sep 2026 15:07:24 +0200
Subject: [PATCH 2/2] fix: diff scope menu shows correct file counts (#12)

The diff panel's "Uncommitted changes" row read a git status that the server
only refreshes on focus or at turn end, so it said "No uncommitted changes"
while files had changed. Its count also double counted renames: numstat's
abbreviated rename paths were parsed into broken paths, and porcelain rename
records were read as their old path.

- Status now reads `git diff --numstat -z` and `git status --porcelain=2 -z`,
  so renames, quoted paths and unborn repos list each file once.
- The scope menu refreshes git status and commits when opened, and shows a
  file count for "All changes".
- Diff stats hide a zero side instead of showing "+0" or "-0".

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/server/src/vcs/GitVcsDriverCore.test.ts  | 55 ++++++++++-
 apps/server/src/vcs/GitVcsDriverCore.ts       | 98 +++++++------------
 apps/web/src/components/DiffPanel.tsx         | 23 ++++-
 .../web/src/components/chat/DiffStatLabel.tsx | 17 ++--
 .../src/components/diffs/DiffScopeMenu.tsx    | 25 +++--
 5 files changed, 137 insertions(+), 81 deletions(-)

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/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 ? (
               <>