[gchen0002]

Problem

With branch-change totals enabled, Git status scans for untracked files twice. The first scan already identifies the untracked paths. The second starts at the repository root again, which costs time in large repositories.

Change

Pass the untracked paths from porcelain status to the existing ls-files --others call. Rooted, literal pathspecs handle nested callers and names such as bulk[1].

Keep the full scan when status returns no untracked paths, including when Git hides them. Also keep it for more than 128 paths or an estimated argument length of 8,000 characters or more. Those limits cap Git's path-matching work and keep the command below Windows' command-line limit.

Scope and approval

This fixes a redundant scan in one existing status operation and extends two existing tests.

Verification

The focused regression command passes both cases:

vp test run apps/server/src/vcs/GitVcsDriverCore.test.ts -t "counts many untracked files exactly|reads Changes totals with untracked files"

The new assertion failed on main because it scanned the whole repository. The tests cover literal names, nested callers, ignored files, hidden untracked files, and the fallbacks for too many or long paths.

Targeted format and lint checks, vp run --filter t3 typecheck, and the commit hook's knip:check pass. The agent-context-budget test also passes.

The full Git driver test file has 199 passes, 9 failures, and 4 skips. I reran all nine failing cases with main's production file and got the same failures.

Existing Windows test failures

• Five SSH authentication and host-key classification cases report an unreachable remote.
• The root-commit and shallow-boundary fixture exits with a Git error.
• The pathspec-magic fixture tries to create :(exclude)after.ts, which Windows rejects.
• The nested-project fixture fails to launch Git from a repository path ending in a space.
• The worktree test expects backslashes where Git reports forward slashes.

vp run check:changed origin/main --concurrency 1 stalled while enumerating ignored files, before it reached the checks. I stopped it and ran the checks above directly.

I verified this on Windows with Node 24.18.0 and Git 2.41.0.windows.1. I haven't checked Node 26, the repository's required version, or other operating systems.

Backend timing

I compared main at 54c5f25249961a1aa0b61932329092eadbd9d6fc with this PR at 24b84d3bdef8b220879bf39de5575d1c4cd50168. Each observation times the complete statusDetailsLocal(cwd, { includeDivergence: false, includeBranchChanges: true }) call.

The test repository has 30,720 tracked source files plus .gitignore, 3,840 module directories with ignored generated output, and 43 untracked files. Git fsmonitor and the untracked cache are off. System and global Git configuration are isolated.

After one warm-up per version, I ran 20 pairs and alternated which version ran first.

Scenario	main	this PR	Mean change
Complete backend status call	1.931 s	1.562 s	-19.1%

These are arithmetic means. Negative change means less elapsed time. Both versions returned the same complete status objects in every pair and launched 16 Git commands per call. The original index's SHA-256 stayed unchanged.

This measures one synthetic repository with warm filesystem caches. I haven't measured UI latency, CPU use, or whole-app performance. The fallback cases still scan the full repository. Totals can lag by one refresh if a new untracked root appears after porcelain status.

Raw paired timings

pair,main_ms,this_PR_ms,main_commands,this_PR_commands
1,2013.585900,1529.230000,16,16
2,1942.368900,1669.311900,16,16
3,1823.466100,1600.276500,16,16
4,1940.087900,1582.210300,16,16
5,1911.395900,1552.746000,16,16
6,1815.887600,1815.462600,16,16
7,2037.883700,1597.926900,16,16
8,1890.806800,1491.425200,16,16
9,1888.116200,1511.805200,16,16
10,2073.743700,1530.302700,16,16
11,1955.319500,1641.313800,16,16
12,1822.134100,1526.558300,16,16
13,1871.727200,1493.245900,16,16
14,1946.453300,1549.523100,16,16
15,1867.479100,1528.168900,16,16
16,1937.747700,1503.718700,16,16
17,1968.780700,1461.190200,16,16
18,1934.116800,1476.890700,16,16
19,2066.528000,1582.509100,16,16
20,1922.237100,1592.309600,16,16

Reproduce the benchmark

Install dependencies, save this script outside the checkout as benchmark.mjs, and run node path/to/benchmark.mjs from this PR checkout's root.

The script creates a disposable Git repository and isolated runtime state. It runs both production modules against that repository and writes final-raw.jsonl and final-summary.json beside the script. The recorded run reused this same disposable fixture through the optional fixture-path argument.

Source SHA-256 after LF normalization: main 4db6b6389dea13d0143c2f6d6ff8fd90b5bff4b3ee7bb21a0089d338dc1bb82f; this PR 1e57b61ef13605757ab7320c15cd2d5529c2f088c4cfebb013bbc448743cc99b.

import fs from "node:fs";
import fsp from "node:fs/promises";
import path from "node:path";
import os from "node:os";
import { pathToFileURL, fileURLToPath } from "node:url";
import { createRequire, registerHooks } from "node:module";
import { execFileSync } from "node:child_process";
import { createHash } from "node:crypto";
import { performance } from "node:perf_hooks";
import assert from "node:assert/strict";

// Run from the PR checkout root; an optional argument reuses this exact disposable fixture.
const root = process.cwd();
const output = path.dirname(fileURLToPath(import.meta.url));
const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "t3-git-status-bench-"));
const emptyConfig = path.join(scratch, "empty.gitconfig");
fs.writeFileSync(emptyConfig, "");
Object.assign(process.env, {
  GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: emptyConfig,
  GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0",
});
const git = (cwd, args) => execFileSync("git", args, {
  cwd, windowsHide: true, encoding: "utf8", maxBuffer: 4 * 1024 * 1024,
});
const cwd = process.argv[2] ?? path.join(scratch, "repo");
if (!process.argv[2]) {
  fs.mkdirSync(cwd);
  git(cwd, ["init", "-q", "--initial-branch=main"]);
  for (const [key, value] of [["core.autocrlf", "false"], ["core.fsmonitor", "false"], ["core.untrackedCache", "false"]]) {
    git(cwd, ["config", key, value]);
  }
  fs.writeFileSync(path.join(cwd, ".gitignore"), "**/build/\n");
  for (let offset = 0; offset < 3840; offset += 32) {
    await Promise.all(Array.from({ length: Math.min(32, 3840 - offset) }, async (_, j) => {
      const i = offset + j;
      const dir = path.join(cwd, "src", `group-${Math.floor(i / 20)}`, `module-${i}`);
      await fsp.mkdir(path.join(dir, "build"), { recursive: true });
      await Promise.all(Array.from({ length: 8 }, (_, f) => fsp.writeFile(path.join(dir, `file-${f}.txt`), `tracked ${i} ${f}\n`)));
      await fsp.writeFile(path.join(dir, "build", "generated.txt"), "ignored output\n");
    }));
  }
  git(cwd, ["add", "."]);
  git(cwd, ["-c", "user.name=Fixture", "-c", "user.email=fixture@invalid", "commit", "-qm", "fixture"]);
  git(cwd, ["checkout", "-qb", "feature/performance"]);
  fs.mkdirSync(path.join(cwd, "new directory", "nested"), { recursive: true });
  for (let i = 0; i < 20; i++) {
    fs.writeFileSync(path.join(cwd, "new directory", "nested", `new-${i}.txt`), "new line\n");
    fs.writeFileSync(path.join(cwd, "src", "group-0", "module-0", `new-${i}.txt`), "new line\n");
  }
  for (const name of ["!literal.txt", "space name.txt", "bracket[1].txt"]) fs.writeFileSync(path.join(cwd, name), "literal path\n");
}
assert.ok(fs.existsSync(path.join(cwd, "src", "group-191", "module-3839", "file-7.txt")));
git(cwd, ["config", "status.showUntrackedFiles", "normal"]);

const source = "apps/server/src/vcs/GitVcsDriverCore.ts";
const coreUrl = pathToFileURL(path.join(root, source)).href;
const base = "54c5f25249961a1aa0b61932329092eadbd9d6fc";
const mainSource = git(root, ["show", `${base}:${source}`]).replaceAll("\r\n", "\n");
const prSource = fs.readFileSync(new URL(coreUrl), "utf8").replaceAll("\r\n", "\n");
registerHooks({
  load(url, context, nextLoad) {
    const loaded = nextLoad(url, context);
    if (url === coreUrl + "?benchmark=main") return { ...loaded, source: mainSource };
    if (url === coreUrl + "?benchmark=pr") return { ...loaded, source: prSource };
    return loaded;
  },
});
const require = createRequire(path.join(root, "apps/server/package.json"));
const dependency = name => import(pathToFileURL(require.resolve(name)).href);
const Effect = await dependency("effect/Effect");
const NodeServices = await dependency("@effect/platform-node/NodeServices");
const { ChildProcess, ChildProcessSpawner } = await dependency("effect/process");
const ServerConfig = await import(pathToFileURL(path.join(root, "apps/server/src/config.ts")).href);
const modules = { main: await import(coreUrl + "?benchmark=main"), pr: await import(coreUrl + "?benchmark=pr") };
const sha256 = data => createHash("sha256").update(data).digest("hex");
const indexHash = () => sha256(fs.readFileSync(path.join(cwd, ".git/index")));
const before = indexHash();
const rows = [];
await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
  const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
  let commands = [];
  const spawner = ChildProcessSpawner.make(command => {
    if (ChildProcess.isStandardCommand(command)) commands.push([...command.args]);
    return delegate.spawn(command);
  });
  const drivers = {};
  for (const [name, module] of Object.entries(modules)) {
    drivers[name] = yield* module.makeGitVcsDriverCore().pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
  }
  const run = (variant, pair) => Effect.gen(function* () {
    commands = [];
    const started = performance.now();
    const status = yield* drivers[variant].statusDetailsLocal(cwd, { includeDivergence: false, includeBranchChanges: true });
    const elapsedMs = performance.now() - started;
    assert.deepEqual(status.branchChanges, { baseRef: "main", insertions: 43, deletions: 0 });
    if (pair >= 0) rows.push({ variant, pair, elapsedMs, commands });
    return status;
  });
  assert.deepEqual(yield* run("main", -1), yield* run("pr", -1));
  for (let pair = 0; pair < 20; pair++) {
    const order = pair % 2 ? ["pr", "main"] : ["main", "pr"];
    assert.deepEqual(yield* run(order[0], pair), yield* run(order[1], pair));
    if ((pair + 1) % 5 === 0) console.log(`Completed ${pair + 1}/20 pairs; identical complete status objects`);
  }
})).pipe(Effect.provide(ServerConfig.layerTest(cwd, path.join(scratch, "runtime"))), Effect.provide(NodeServices.layer)));
assert.equal(indexHash(), before);
const mean = variant => rows.filter(r => r.variant === variant).reduce((n, r) => n + r.elapsedMs, 0) / 20;
const mainMs = mean("main"), prMs = mean("pr");
const summary = {
  base, head: git(root, ["rev-parse", "HEAD"]).trim(), mainMs, prMs,
  meanChangePercent: (prMs / mainMs - 1) * 100, pairs: 20,
  commandsPerCall: [...new Set(rows.map(r => r.commands.length))],
  completeResultsIdentical: true, originalIndexUnchanged: true,
  mainSourceSha256: sha256(mainSource), prSourceSha256: sha256(prSource),
  platform: process.platform, node: process.version, git: git(root, ["--version"]).trim(),
};
fs.writeFileSync(path.join(output, "final-raw.jsonl"), rows.map(r => JSON.stringify(r)).join("\n") + "\n");
fs.writeFileSync(path.join(output, "final-summary.json"), JSON.stringify(summary, null, 2));
console.log(JSON.stringify(summary));

Model: gpt-6.1-sol; harness: Codex (T3 Code).

[coderabbitai]

No actionable comments were generated in the recent review.

Recent review info

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: main
• File: .coderabbit.config.ts
• Commit: 54c5f25
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Advanced
• Run ID: 2f90bc9c-ad5d-45e5-9664-cda5d58d8296

Commits

Reviewing files that changed from the base of the PR and between 54c5f25 and 33c7ea5.

Files selected for processing: 2

• apps/server/src/vcs/GitVcsDriverCore.test.ts
• apps/server/src/vcs/GitVcsDriverCore.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 9 remain after this review.

Walkthrough

The change collects untracked paths from porcelain status records and passes them to branch-change totals. The totals function uses bounded literal pathspecs for untracked review-index preparation, with a full-scan fallback. Tests cover bracketed paths, file totals, and status modes.

Changes: Untracked-file scanning

Layer / File(s)	Summary
Collect untracked roots apps/server/src/vcs/GitVcsDriverCore.ts	readStatusDetailsLocal collects paths from untracked porcelain records and passes them to branch-change totals.
Bound pathspec selection and verify scans apps/server/src/vcs/GitVcsDriverCore.ts, apps/server/src/vcs/GitVcsDriverCore.test.ts	readBranchChangeTotals uses literal pathspecs when the root count and estimated length are below the limits; otherwise it uses a full scan. Tests check bracketed paths, ignored-file exclusion, scan roots, status modes, and insertion totals.

Estimated code review effort: 2 (Simple) | ~10 minutes

Change: Refactor

Possibly related issues

• Issue 25558 reports slow readBranchChangeTotals processing for repositories with many untracked files. This change uses untracked paths from porcelain status to limit the later scan.

Suggested reviewers: juliusmarminge, jetpham

Merge Risk: Minimal · up to 33c7e

The change narrows untracked-file scans; no merge-blocking issue was identified.

Pre-merge checks: 4

Check name	Status	Explanation
Title check		The title "perf(server): reuse untracked paths in Git status" is a conventional commit title that matches the main change. The PR passes the untracked paths found by porcelain status to the existing `…
Description check		The description follows the repository template's main sections: Problem, Change, Scope and approval, and Verification. It explains the redundant untracked scan and how the change fixes it, including …
Linked Issues check		Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check		Check skipped because no linked issues were found for this pull request.

Full details: Title check

Explanation

The title "perf(server): reuse untracked paths in Git status" is a conventional commit title that matches the main change. The PR passes the untracked paths found by porcelain status to the existing ls-files --others call, which avoids a second repository-wide untracked scan when branch-change totals are enabled. The title is concise, specific, and free of file lists or vague wording.

Full details: Description check

Explanation

The description follows the repository template's main sections: Problem, Change, Scope and approval, and Verification. It explains the redundant untracked scan and how the change fixes it, including fallback limits. It gives focused test commands and results, the known Windows failures, and a reproducible benchmark with raw timings. The Scope and approval section is weak. It says the change fixes a redundant scan and extends two tests, but it does not link a triaged issue or maintainer approval, and it does not explain why the change qualifies without one. The template also asks for the model and harness used, and the description includes this at the end. Because the rest of the template is covered, the check passes, but the author should add the missing approval link or exemption rationale.

Finishing Touches

Generate unit tests (beta)

• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

[maria-rcks]

Note

Written by gpt-6.1-sol on behalf of Maria

Verified in a real dev environment

verified head 33c7ea5405a8f0b852cde1167f332d716171a1e4 on linux in chrome, driven with the repository's playwright dependencies. ran vp i and a background vp run dev on github/main (8b74a69019) first, stopped it, then ran the exact pr head. only one dev server ran at a time.

created the local git project through the web app. a real codex gpt-6.1-sol turn created a baseline commit, feature branch, tracked edit, bracketed untracked paths, and an ignored file. reused that same repository and app-created conversation for the pr.

• main and pr both showed changes +4 -0: bulk[1]/a.txt +2, new [1].txt +1, and README.md +1. the changes diff opened and displayed those contents; the ignored file stayed absent.
• the running server's git trace reproduced main's redundant full-repository ls-files --others --exclude-standard -z -- scan. on the pr, the same client flow added :(top,literal)bulk[1]/ and :(top,literal)new [1].txt.
• a second real codex turn on the pr staged only README and set status.showUntrackedFiles=no. after refreshing the app, changes remained +4 -0; the server trace confirmed the full-scan fallback. the diff still included the hidden untracked files and staged edit.
• blacksmith ran the two existing focused regressions with vp test run apps/server/src/vcs/GitVcsDriverCore.test.ts -t "counts many untracked files exactly|reads Changes totals with untracked files": 2 passed, 210 skipped. existing head ci has no failing or pending checks. no source changes were needed.

short running-server transcript

main, same repository:

pr, same repository:

Not verified

native windows/macOS behavior, electron, ios/android, remote/tunnel connections, and node 26.12.1. this vm used node 24.22.1. the small real repository verifies scan selection and correctness, not latency or cpu improvements on large repositories. large-root and long-argument fallbacks were covered by the focused tests, not a separate real-app scenario. the full suite was not rerun.

[gchen0002]

nice nice