Repository navigation
Performance testing
This is the running performance report for the standalone Rust CLI program: a repeatable procedure, and every checkpoint measured with it, newest first. Raw evidence is kept on #151.
Policy (ADR-0037, decision 7). No benchmark result stops the program, blocks a command from going native, or holds the cutover. The owner set this on 2026-09-27: Rust is the right implementation, and interim numbers are information, not a verdict. A result that is slower than the JavaScript CLI becomes an optimization issue, linked from the checkpoint that found it.
Since v0.24.0 (#243) there is no JavaScript
CLI. The harness (format perf-checkpoint-v2) measures the Rust CLI alone, against its Git
floors and under both read engines; checkpoints recorded before then also compare it with the
JavaScript CLI, and their figures stay as recorded. A later checkpoint is compared with the
previous one on the same host, and a regression against it becomes the optimization issue.
| # | When | What it shows | Status |
|---|---|---|---|
| 0 | Before any Rust CLI code | The JavaScript CLI baseline |
Recorded 2026-09-27 (harness 2131c6c1abbe) |
| 1 | After #141, with every command delegated | The cost of the delegating shell on top of the JavaScript CLI |
Recorded 2026-09-28 (harness 2131c6c1abbe, source 1e61159) |
| 2 | After #144, read-only commands native | The first native whole-command numbers |
Recorded 2026-10-01 (harness a29f59a5f2ec, source 386d17c) |
| 3 | After #145, metadata writes | Note writes, envelopes, init and commit |
Recorded 2026-10-02 (harness a29f59a5f2ec, source a98311d) |
| 4 | After #146, landing | Compact landing and cherry-pick | Not measured; covered by checkpoint 9 |
| 5 | After #147, forecast and reconcile | Forecasts on both engines, and reconciliation | Not measured; covered by checkpoint 9 |
| 6 | After #148, causal rebase | Rebase planning, forecast and execution | Not measured; covered by checkpoint 9 |
| 7 | After #149, workspaces and specs | Workspace lifecycle and spec merge | Not measured; covered by checkpoint 9 |
| 8 | After #150, the packaged install | Startup through the npm-installed command, including any launcher | Not measured; the npm install runs the executable itself (no launcher), so checkpoint 9 startup applies |
| 9 | At #152, the cutover | The full picture with no Node on the path |
Recorded 2026-10-17 on lab-linux-a (harness ef6551fec450, source 658c200, v0.25.1); not comparable with 0–3, which ran on lab-windows-a
|
This procedure produces a checkpoint that can be compared with every earlier checkpoint. Follow it exactly. If a step cannot be followed, record the deviation in the checkpoint's section. Do not quietly substitute a step.
A checkpoint has three parts. Part A is new for the Rust CLI program. Parts B and C are the repository's existing harnesses, run unchanged so their history stays comparable.
| Part | Tool | Question it answers |
|---|---|---|
| A. Whole-command benchmark | scripts/perf-checkpoint.mjs |
How long does each cst command take end to end, per implementation, against the plain-Git work it replaces? |
| B. Phase benchmark |
npm run test:benchmark (scripts/benchmark-regression.mjs) |
Did any in-process phase or Git process count regress against the committed lab-windows-a baseline? What is each phase's ratio to plain Git with startup excluded (the 110% criterion)? |
| C. Engine comparison on a real clone | scripts/measure-real-repository.mjs |
Do the Git and native read engines give identical results, and what do native reads save, per phase and per whole command? |
Part A times complete processes: wall time from spawn to exit, measured by the parent, so startup, module loading, the work, and output are all included. That is the number a user feels, and the number a native CLI changes most.
-
Implementations. Each build is named with
--impl <name>=<path to cst executable>, and any number can be compared in one run; the first is the reference. Without--implthe run measures the checkout's own build asrust. Until v0.24.0,js(node bin/cst.js) was always measured too. -
Floors. Where a plain-Git equivalent exists, the same work is timed as a raw
gitinvocation (the "Git floor").--versionis also compared with a bare runtime launch (node -e 0). Floors approximate "the Git work this command does" and are labeled with their exact command in the evidence; they are not claims of equivalence. -
Interleaving. For every measurement, each side (each implementation and each floor) runs 3 untimed warm-ups, then 21 timed samples, interleaved. The starting side rotates each round, so no side always runs first and drift in host load spreads evenly.
-
Git process counts. One extra traced run (
VLAB_TRACE=1) per command and implementation counts the Git processes launched: the(new process)and(new persistent process)trace lines. A Rust CLI must print the same trace lines for this to work (#141). -
Equality. Every read marked deterministic is hashed on every sample. The run fails if a read prints different bytes between samples, between the Git and native engines, or between implementations.
doctoris excluded because it prints timings. -
Exit status. A read may legitimately exit non-zero to report findings (
audit identitydoes on the scale fixture), and the status is recorded. It must be the same on every sample. A changing status, such as a crash, stops the run. Every write and every floor must exit 0. -
Engines. Reads run twice:
CAUSET_ENGINE=gitandCAUSET_ENGINE=native. Native is skipped, and the skip recorded, whencst doctorreports the native engine unavailable. Writes run under default settings, and the two forecast engines are measured as separate commands. -
Environment. Every child gets the same controlled environment:
-
GIT_CONFIG_NOSYSTEM=1; - a generated global Git configuration (fixed identity,
core.autocrlf=false); -
GIT_TERMINAL_PROMPT=0; - fixed author and committer dates;
- no
VLAB_*variables and no launcher-injectedGIT_CONFIG_COUNT/GIT_CONFIG_KEY_*/GIT_CONFIG_VALUE_*, which the native engine refuses.
The user's own Git configuration never reaches a measured command.
-
Fixtures. They are built fresh by the script on every run and deleted afterwards (keep them
with --keep):
| Fixture | Contents | Pinning |
|---|---|---|
real |
A --no-local clone of this repository, detached, holding refs/notes/vcs-lab and refs/vcs-lab/retention as a repository from before the rename did, then moved to the causet names with cst migrate. Both refs are fetched from the source's refs/notes/causet and refs/causet/retention, whose history contains the pinned commits |
--real-rev (default v0.18.0), --real-notes (default 4089785, the notes at the v0.18.0 release) and --real-retention (default 0435137, the last tip of the former retention ref) |
scale |
The synthetic fixture of cst metadata benchmark (kept with the CAUSET_TEST_SCALE_FIXTURE test hook; src/scale-benchmark.js built it until v0.24.0) with the committed profile in benchmarks/baseline.json (reduced-local-v3: 100 commits, 4 linked workspaces, 60 causal notes, 12 resolutions, 600 files) |
The profile is versioned in the repository. This is the only fixture with a populated resolution catalog |
template |
A deterministic repository: 35 commits over five areas, one compact landing (receipts and carried provenance), a feature branch of 4 cst commits diverged from main by 3 commits, and a 12-section Markdown spec |
Built by the script with fixed dates. Commit IDs differ run to run only through Change-Ids |
Commands measured:
| Suite | Fixture | Command | Git floor |
|---|---|---|---|
| startup | — | --version |
git --version; bare node -e 0
|
| startup | — | --help |
— |
| reads | real, scale | receipts --json |
git notes --ref=causet list |
| reads | real, scale | provenance --all --json |
git notes --ref=causet list |
| reads | real, scale | resolve list --json |
git for-each-ref refs/causet/resolutions/ |
| reads | real, scale | metadata status --json |
— |
| reads | real, scale | metadata validate --json |
— |
| reads | real, scale | audit identity --json |
— |
| reads | real, scale | graph |
git log --graph --oneline --all |
| reads | real | capabilities --json |
— |
| reads | real |
doctor --json (not deterministic) |
— |
| reads | scale | workspace list |
git worktree list --porcelain |
| reads | template | merge-plan feature --json |
git log --oneline main..feature |
| reads | template | rebase-plan main feature --json |
git log --oneline feature..main |
| reads | template | proof-bundle feature |
— |
| writes | template copy |
commit (a staged file) |
git commit |
| writes | template copy | merge feature --compact |
git merge --no-ff feature |
| writes | template copy | cherry-pick <feature tip> |
git cherry-pick |
| writes | template copy |
forecast feature --json, worktree engine |
git merge-tree --write-tree main feature |
| writes | template copy |
forecast feature --json, merge-tree engine |
git merge-tree --write-tree main feature |
| writes | template copy | reconcile feature --json |
git merge --no-ff feature |
| writes | template copy |
rebase main --json, from feature
|
git rebase main |
| writes | template copy | workspace create bench-ws --json |
git worktree add -b bench-ws |
| writes | template copy | metadata export ../bench-export --json |
— |
| writes | template copy | spec index specs/design.md --json |
— |
Each write sample and each floor sample runs in its own fresh copy of the template. Copying,
per-command setup (staging a file, switching to feature) and cleanup are outside the timed
region.
The reference host is lab-windows-a (see Benchmark host baselines).
Other hosts may run the procedure, but their results are reported separately and never compared
with lab-windows-a figures.
- Plug the machine into power and select the Balanced or High performance power plan. Use the same plan as the previous checkpoint and record which.
- Close games, streaming and capture tools, virtual machines, other test suites, and anything else
that keeps a CPU busy. Check that no other agent session is running
npm testor a benchmark. Two runs in one%TEMP%interfere with each other. - Run from a checkout outside any synced folder (OneDrive, Proton Drive, Dropbox). The
fixtures live under
%TEMP%, which must not be synced either. - Leave Windows Defender as it is, but record whether real-time protection is on:
Get-MpComputerStatus | Select RealTimeProtectionEnabled. It affects process start time, and turning it off would measure a machine no user has. - Wait for the machine to settle, about two minutes after closing things. The script samples
load from the kernel's CPU counters without spawning anything: five one-second readings, with
the median as the figure and the maximum recorded beside it. It refuses to start when the
median is above 30% (
--max-cpu). Only use--allow-noisywhen a noisy measurement is better than none, and say so in the section.
-
Check out the exact commit under test, in a clean tree:
git switch --detach <commit> git status --porcelain # must print nothing
-
Check the toolchain and record the versions:
node --version(Node 24 or later),git --version(2.49 or later, so the merge-tree forecast engine is measured), andrustc --version(the pinned toolchain). -
Build the CLI, which carries both read engines:
npm run build:native
It is built in release mode at the same commit, at
native/target/release/cst.exe(cstoff Windows). Before v0.24.0 the same command also built the optional native binding.
Run from the checkout root, in Git Bash or PowerShell. Choose new output files outside the checkout:
node scripts/perf-checkpoint.mjs \
--host lab-windows-a \
--checkpoint <n> \
--output <outside-the-checkout>/perf-checkpoint-<n>.json \
--markdown <outside-the-checkout>/perf-checkpoint-<n>.md \
[--impl rust=<path-to-cst-executable>] \
[--note "<anything unusual about the host>"]-
Expected: progress lines on stderr, one per command, then
wrote … N measurements in … s, and exit 0. A full run with one implementation took 17 minutes onlab-windows-aat checkpoint 0 (84 measurements), including fixture setup. Each added implementation adds roughly a third. - Exit 1 with "equality problems": a deterministic read printed different bytes. That is a finding. Keep the output files and report it on #151; do not rerun until it is understood.
- Keep the defaults: 21 samples and 3 warm-ups. Fewer samples are allowed only for a smoke run, which is never recorded as a checkpoint.
VLAB_BENCHMARK_HOST=lab-windows-a npm run test:benchmark > <outside>/benchmark-<n>.log-
Expected:
Benchmark regression check using hosts.lab-windows-a, then per-phase lines and the "Work against the plain-Git equivalent" table. - A reported regression is recorded, not acted on here. The committed baseline is re-recorded
only through the process in
docs/testing.md, never to make a checkpoint pass.
git clone --no-local <this checkout> <short-temp-path>/vlab-real
git -C <short-temp-path>/vlab-real fetch origin '+refs/notes/causet:refs/notes/vcs-lab' '+refs/causet/retention:refs/vcs-lab/retention'
git -C <short-temp-path>/vlab-real switch --detach <same --real-rev as Part A>
git -C <short-temp-path>/vlab-real update-ref refs/notes/vcs-lab <same --real-notes as Part A>
git -C <short-temp-path>/vlab-real update-ref refs/vcs-lab/retention <same --real-retention as Part A>
git -C <short-temp-path>/vlab-real remote remove origin
(cd <short-temp-path>/vlab-real && <cst under test> migrate)
env -u GIT_CONFIG_COUNT -u GIT_CONFIG_KEY_0 -u GIT_CONFIG_KEY_1 -u GIT_CONFIG_VALUE_0 -u GIT_CONFIG_VALUE_1 \
node scripts/measure-real-repository.mjs --repo <short-temp-path>/vlab-real --host lab-windows-a \
--output <outside>/real-<n>.json- Use a short path such as
%TEMP%\vlab-real, because resolution refs need Windows path headroom. - Fetch the source's current refs into the former names, as Part A's
realfixture does, and pin both before migrating. Fetchingrefs/notes/causetunder its own name would leave the clone reading the source's latest notes in place of the pinned ones (checkpoint 2). Origin's frozenrefs/notes/vcs-labandrefs/vcs-lab/retentionare no longer needed (#232). -
cst migrateis required since the migration window ended (#170): the build under test refuses the clone until it has run. - Omit the
env -u …prefix when no launcher injects those variables. - Delete the clone afterwards.
- Expected: "identical domain and CLI results across engines" for every phase, and exit 0.
A checkpoint is recorded only if all of these hold:
- Part A exited 0: no equality problems, and every write and floor succeeded.
- Part A's
noisyisfalse, or the section says why a noisy run was accepted. - Part C reports identical results across engines.
-
git status --porcelainin the checkout is still empty. - No
vlab-perf-*,causet-scale-benchmark-*orvlab-realdirectory is left in%TEMP%, unless--keepwas used deliberately.
-
Paste Part A's
--markdownoutput into this page as a new section under Checkpoints recorded, newest first. Add:- Part B's plain-Git ratio table and its regression verdict;
- Part C's per-phase table;
- the power plan and Defender state;
- Findings: what changed since the previous checkpoint and why, as far as it is known.
-
Post the raw evidence on #151, one comment per file:
- the Part A JSON;
- the Part B log's tables;
- the Part C JSON.
GitHub comments are limited to 65,536 characters. If a file is larger, split it by suite (startup, reads, writes) across consecutive comments, each labeled "part k of n". Never commit evidence to the repository.
-
Update the checkpoint's row in the table at the top of this page.
-
Slower than the reference. For any command where an implementation's median is higher than the reference's (Part A lists these under "Slower than
<reference>"), or, with one implementation, higher than at the previous checkpoint on this host, and the gap is larger than both sides' IQRs, file an optimization issue:- title:
perf: <command> is slower than <reference or checkpoint> (checkpoint <n>); - body: the two medians and p90s, the Git process counts on both sides, the fixture, the suspected cause, and a link to this checkpoint;
- labels:
enhancement; board: Area Native core and performance, Gate Nothing — ready to work.
Link the issue from the checkpoint's Findings.
- title:
-
More Git processes than the reference or the previous checkpoint. Same treatment. Process counts are reported, not part of parity (ADR-0037).
-
Faster. Record it. No action.
Never revert, pause, or hold a port because of a result (ADR-0037, decision 7).
-
Only compare like with like: the same host, the same power plan, the same harness
(
scriptSha256in the evidence), and the same fixture pins. If the harness changes, re-run the previous checkpoint's build with the new harness first, and mark the old figures as not comparable. - Read medians first, then p90 for tail behavior. A difference smaller than the larger of the two IQRs is within noise on this host.
- Report ratios against the Git floor alongside milliseconds. Ratios survive changes in host load better than absolute times do.
- Whole-command times (Part A) include startup. Part B's ratios exclude it. Quote the right one for the claim being made.
.github/workflows/perf.yml
runs Part A on GitHub-hosted Windows and Ubuntu runners, with the Rust CLI added automatically
once the workspace builds a vlab binary. It runs on these triggers:
- Manual dispatch (Actions → perf → Run workflow), with inputs for the sample count (at least 5, default 11) and the suites;
-
weekly on
main, on Mondays at 06:17 UTC; -
pull requests touching
native/,scripts/perf-checkpoint.mjs, or the workflow.
What a hosted run can and cannot tell you. The runners are shared virtual machines, and their hardware can differ from run to run. So:
| Trust across runs | Trust within one run only | Do not use |
|---|---|---|
| Byte equality, exit status, Git process counts (per platform; see below) | Native against Git engine, each command against its Git floor (as ratios); until v0.24.0, Rust against JavaScript | Absolute milliseconds, or comparisons between two hosted runs |
Process counts are exact per platform. This was verified on the first hosted run (36327659099).
- The hosted Windows runner matched checkpoint 0 on
lab-windows-aon all 52 JavaScript CLI counts, on different hardware under unknown load. - Ubuntu launches more processes for 16 commands, for example
metadata status13 instead of 10, andmerge-plan13 instead of 9. That is by design: the Git object session (ADR-0009) is on by default only on Windows. - So compare counts between runs on the same platform, never across platforms.
The hosted run complements a checkpoint; it does not replace one. A checkpoint's timings always come from the reference host through steps 1–7.
Where the output goes.
- The run's page shows the Markdown summary.
- The JSON evidence is the
perf-<os>-<sha>artifact, kept for 90 days. - To cite a hosted run in a checkpoint's Findings, link the run and quote its ratios and process counts, not its milliseconds.
When it fails. It fails only when the harness cannot measure: a command failed, or a deterministic read printed different bytes. Timings never fail it. Treat a failure like a Part A exit 1: open the run, read the error, and report it on #151. A process count that changes between two hosted runs is worth an issue, because counts do not depend on load.
The harness is versioned with the repository. A change to its commands, fixtures, statistics, or environment is a pull request that:
- updates this page's command and fixture tables;
- states whether earlier checkpoints stay comparable;
- if they do not, records a fresh baseline of the previous checkpoint's build under the new harness.
Measured at the v0.25.1 release commit 658c200, with the CLI built in release mode at that commit (native/target/release/cst, causet 0.25.1), in a clean checkout. The harness is ef6551fec450 (format perf-checkpoint-v2), and Part C's script is 70f052ceea27.
These figures stand alone, for two reasons:
- There is no JavaScript CLI to compare against. It was removed in v0.24.0 (#243), so this checkpoint measures the Rust CLI alone, against the plain-Git work each command replaces, under both read engines.
-
This is a new host. It is the first checkpoint on
lab-linux-a, and the procedure compares only like with like, so none of these figures is comparable with checkpoints 0–3, which were all measured onlab-windows-a. The next checkpoint on this host is compared with this one.
Deviations from the procedure, all forced by the host:
- Step 1 is written for Windows. This host is Fedora 44 (Linux 7.2.10) on AC power, so there is no power plan or Defender to record.
- The open applications were an IDE and a local logging service, both idle. Load stayed at 3–4% CPU throughout.
- The harness runs
cstdirectly, so no Node process is on the measured path. Node starts only the harness itself.
Checkpoints 4–8 were not measured: the milestones they waited for shipped before any of them was run, and the JavaScript CLI each was to be compared against is gone. This checkpoint covers their commands:
- landing and cherry-pick (4);
- both forecast engines and reconcile (5);
- causal rebase (6);
- workspace create and list, and spec index (7).
For 8, the packaged install: npm install --allow-scripts=@holland-vip/causet puts the executable itself on the path (cst doctor reports launcher: null, verified on the v0.25.1 install on #274), so its startup is the executable's startup measured here.
-
Host:
lab-linux-a, AMD Ryzen 7 5800X3D 8-Core Processor, 16 logical CPUs, 31 GiB, Linux 7.2.10-200.fc44.x86_64 -
Versions: Node v26.8.1, git version 2.56.0. Source
658c200, harnessef6551fec450 -
Implementations:
rust(causet 0.25.1) -
Native engine: available (
files-sha1-resolution-v1) - Sampling: 21 timed samples after 3 warm-ups, interleaved across sides. Whole-process wall time
- Load: start 3% CPU (max 7%) / 16.5 GiB free; after fixtures 3% CPU (max 6%) / 16.5 GiB free; end 4% CPU (max 6%) / 16.5 GiB free. Note: Fedora 44 (Linux 7.2.10), 16 logical CPUs, on AC power; an IDE and a local logging service were open but idle; the first Linux checkpoint
-
Fixtures:
template: deterministic repository: 32 commits on main (52 across all refs, including notes), one compact landing with receipts and carried provenance, a feature branch of 4 vlab commits diverged by 3, a 12-section Markdown spec (52 commits);real: --no-local clone of this repository at v0.18.0 with refs/notes/vcs-lab pinned to 4089785 and refs/vcs-lab/retention pinned to 0435137, then moved to the causet names with cst migrate (237 commits);scale: synthetic scale fixture, profile reduced-local-v3: 100 commits, 4 workspaces, 60 causal notes, 12 resolutions, 600 files - Equality: every deterministic read printed identical bytes across samples, engines and implementations
- Duration: 78 s
| Fixture | Command | Engine | rust median (p90) | Git floor | rust / floor | rust Git processes |
|---|---|---|---|---|---|---|
| template | --version |
default | 2.0 (2.1) | 2.0; bare Node 22.3 | 99% | 0 |
| template | --help |
default | 1.9 (2.0) | — | — | 0 |
| Fixture | Command | Engine | rust median (p90) | Git floor | rust / floor | rust Git processes |
|---|---|---|---|---|---|---|
| real | receipts --json |
git | 14.1 (14.8) | 2.6 | 534% | 3 |
| real | receipts --json |
native | 11.2 (11.5) | 2.7 | 409% | 0 |
| real | provenance --all --json |
git | 201.6 (204.0) | 2.8 | 7174% | 102 |
| real | provenance --all --json |
native | 201.0 (202.6) | 2.9 | 7054% | 99 |
| real | resolve list --json |
git | 4.5 (4.7) | 2.2 | 204% | 2 |
| real | resolve list --json |
native | 2.9 (3.0) | 2.2 | 130% | 0 |
| real | metadata status --json |
git | 35.4 (36.7) | — | — | 15 |
| real | metadata status --json |
native | 25.6 (26.5) | — | — | 3 |
| real | metadata validate --json |
git | 35.9 (36.9) | — | — | 15 |
| real | metadata validate --json |
native | 25.1 (26.9) | — | — | 3 |
| real |
audit identity --json (exits 1) |
git | 23.9 (25.1) | — | — | 4 |
| real |
audit identity --json (exits 1) |
native | 20.4 (21.2) | — | — | 1 |
| real | graph |
git | 20.6 (21.9) | 10.7 | 193% | 4 |
| real | graph |
native | 17.6 (18.6) | 10.3 | 170% | 1 |
| scale | receipts --json |
git | 11.2 (11.9) | 2.4 | 460% | 3 |
| scale | receipts --json |
native | 10.4 (11.3) | 2.4 | 431% | 0 |
| scale | provenance --all --json |
git | 11.5 (11.8) | 2.4 | 475% | 4 |
| scale | provenance --all --json |
native | 10.4 (11.0) | 2.5 | 420% | 1 |
| scale | resolve list --json |
git | 14.4 (14.9) | 2.7 | 538% | 7 |
| scale | resolve list --json |
native | 11.3 (11.8) | 2.6 | 431% | 0 |
| scale | metadata status --json |
git | 41.6 (42.4) | — | — | 19 |
| scale | metadata status --json |
native | 39.7 (42.2) | — | — | 3 |
| scale | metadata validate --json |
git | 41.8 (42.8) | — | — | 19 |
| scale | metadata validate --json |
native | 39.7 (40.9) | — | — | 3 |
| scale |
audit identity --json (exits 1) |
git | 20.1 (20.8) | — | — | 4 |
| scale |
audit identity --json (exits 1) |
native | 18.8 (19.8) | — | — | 1 |
| scale | graph |
git | 15.1 (15.8) | 9.5 | 159% | 4 |
| scale | graph |
native | 14.2 (15.1) | 9.1 | 156% | 1 |
| real | capabilities --json |
git | 6.3 (6.5) | — | — | 2 |
| real | capabilities --json |
native | 5.7 (5.9) | — | — | 1 |
| real | doctor --json |
git | 6.9 (7.0) | — | — | 4 |
| real | doctor --json |
native | 5.0 (5.2) | — | — | 1 |
| scale | workspace list |
git | 15.1 (15.5) | 2.5 | 593% | 5 |
| scale | workspace list |
native | 14.4 (14.8) | 2.6 | 560% | 4 |
| template | merge-plan feature --json |
git | 24.2 (24.7) | 3.0 | 802% | 13 |
| template | merge-plan feature --json |
native | 20.7 (21.2) | 3.1 | 660% | 8 |
| template | rebase-plan main feature --json |
git | 27.7 (28.0) | 3.0 | 911% | 15 |
| template | rebase-plan main feature --json |
native | 23.9 (24.6) | 3.0 | 788% | 10 |
| template | proof-bundle feature |
git | 56.4 (57.9) | — | — | 33 |
| template | proof-bundle feature |
native | 42.3 (43.1) | — | — | 16 |
| Fixture | Command | Engine | rust median (p90) | Git floor | rust / floor | rust Git processes |
|---|---|---|---|---|---|---|
| template | commit |
default | 26.4 (27.1) | 5.4 | 492% | 15 |
| template | merge --compact feature |
default | 69.3 (70.5) | 8.4 | 821% | 40 |
| template | cherry-pick <feature tip> |
default | 56.8 (57.8) | 5.0 | 1142% | 35 |
| template | forecast feature (worktree engine) |
default | 74.2 (75.3) | 3.2 | 2303% | 36 |
| template | forecast feature (merge-tree engine) |
default | 38.9 (39.4) | 3.3 | 1197% | 19 |
| template | reconcile feature |
default | 217.3 (219.3) | 8.6 | 2527% | 134 |
| template | rebase main (from feature) |
default | 254.9 (255.8) | 14.5 | 1756% | 160 |
| template | workspace create |
default | 12.3 (12.6) | 8.0 | 154% | 3 |
| template | metadata export |
default | 65.0 (66.2) | — | — | 37 |
| template | spec index specs/design.md |
default | 4.9 (5.0) | — | — | 2 |
This host has no identified baseline, so this is the deterministic-only check against hosts.github-ubuntu-latest (the 2026-10-09 baseline): no deterministic regression. Every process count and materialization figure is unchanged, and latency comparison was skipped. Node startup is excluded from both sides:
| Phase | cst | Plain Git | Ratio | Processes, cst / Git |
|---|---|---|---|---|
history |
2.89 ms | 3.02 ms | 96% | 1 / 1 |
gitWorktrees |
1.59 ms | 1.97 ms | 81% | 1 / 1 |
workspaceStatus |
28.27 ms | 12.09 ms | 234% | 4 / 4 |
noteCatalog |
7.52 ms | 5.01 ms | 150% | 2 / 2 |
resolutionCatalog |
11.76 ms | 3.14 ms | 375% | 6 / 2 |
metadataStatus |
34.47 ms | 11.53 ms | 299% | 14 / 6 |
workspaceCreate |
25.22 ms | 22.22 ms | 114% | 2 / 1 |
workspaceCreateCone |
14.21 ms | 10.18 ms | 140% | 4 / 3 |
The clone: v0.18.0 with notes 4089785 and retention 0435137, moved with cst migrate, 237 reachable commits and 388 tracked files. It was prepared exactly as step 5 says and run with the injected GIT_CONFIG_* variables removed.
Result: the Git and native engines gave identical CLI results for every phase, and the repository was unchanged. Since #243, the whole-CLI column runs the Rust CLI. Times are median / p95 in ms (p95 is the maximum of nine samples):
| Phase | Results | Git engine, whole CLI | Native, whole CLI | Native / Git |
|---|---|---|---|---|
noteCatalog |
146 | 14.0 / 15.2 | 11.1 / 11.8 | 0.79 |
resolutionCatalog |
0 | 4.6 / 4.8 | 3.1 / 3.2 | 0.67 |
metadataStatus |
— | 35.4 / 37.1 | 26.1 / 28.7 | 0.74 |
-
Whole commands now take milliseconds on this host:
- startup is 2.0 ms, 99% of
git --version; - the 40 read measurements run from 2.9 ms (
resolve liston the real clone, native engine) to 56 ms (proof-bundle), apart fromprovenance --allon the real clone; - a compact landing takes 69 ms, a forecast 39 ms (merge-tree engine) or 74 ms (worktree engine), a reconcile 217 ms and a causal rebase 255 ms.
- startup is 2.0 ms, 99% of
-
The native engine is never slower, and it removes most Git processes where its catalog applies:
-
metadata statusandvalidatego from 15 to 3 processes on the real clone, and from 19 to 3 on the scale fixture; -
proof-bundlegoes from 33 to 16 processes and from 56.4 to 42.3 ms; -
receiptsandresolve liststart no Git process at all.
-
-
provenance --all --jsonon the real clone is the outlier: 201 ms under either engine, with 102 or 99 Git processes, about one per commit inspected. The native engine saves only 3 processes because the per-commit work is outside its catalog. On the 100-commit scale fixture the same command takes 10–12 ms with 1–4 processes, so the cost follows the number of commits carrying provenance on the real clone. It is the most process-bound read in the harness. The step 8 rule files an optimization issue only for a regression against a reference or an earlier checkpoint on this host; with neither, it is recorded here as the first candidate. -
Part B's in-process ratios are over 110% for the catalog and status phases (
resolutionCatalog375%,metadataStatus299%,workspaceStatus234%). These are reported, not enforced, and they match the extra Git processes those phases launch. -
Optimization issues: none filed. There is no earlier checkpoint on
lab-linux-ato regress against.
Measured with this procedure at a98311d (#145 completed through PR #194), in a clean detached checkout, with the Rust CLI built in release mode at the same commit (native/target/release/cst.exe). Since checkpoint 2 the Rust CLI also answers init, commit, and metadata retain, export, import and dispose natively. Part A measures two of them, commit and metadata export; every other write and workspace list still delegate. Host conditions: the Balanced power plan, Defender real-time protection on, and in the background idle Claude Code and Codex sessions and an Expo dev server for another project, which checkpoint 2 did not have. No game or suite was running. The harness (a29f59a5f2ec) and Part C's script (8d7be7aa56c7) are unchanged since checkpoint 2, so every part is comparable. Part C follows the corrected step 5: only refs/notes/vcs-lab is fetched.
-
Host:
lab-windows-a, AMD Ryzen 7 5800X3D 8-Core Processor, 16 logical CPUs, 32 GiB, Windows_NT 10.0.26300 -
Versions: Node v26.4.0, git version 2.55.0.windows.3. Source
a98311d, harnessa29f59a5f2ec -
Implementations:
js(causet 0.20.0),rust(causet 0.20.0) -
Native binding: available (
83b6ec32006a) - Sampling: 21 timed samples after 3 warm-ups, interleaved across sides. Whole-process wall time
- Load: start 12% CPU (max 20%) / 7.4 GiB free; after fixtures 18% CPU (max 22%) / 6.8 GiB free; end 17% CPU (max 19%) / 7.0 GiB free. Note: Balanced power plan; Defender real-time protection on; background: idle Claude Code and Codex sessions, an Expo dev server in another project
-
Fixtures:
template: deterministic repository: 32 commits on main (52 across all refs, including notes), one compact landing with receipts and carried provenance, a feature branch of 4 vlab commits diverged by 3, a 12-section Markdown spec (52 commits);real: --no-local clone of this repository at v0.18.0 with refs/notes/vcs-lab pinned to 4089785 and refs/vcs-lab/* from the source (237 commits);scale: synthetic scale fixture, profile reduced-local-v3: 100 commits, 4 workspaces, 60 causal notes, 12 resolutions, 600 files - Equality: every deterministic read printed identical bytes across samples, engines and implementations
- Duration: 1891 s
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | --version |
default | 105.1 (108.2) | 16.7 (19.7) | 24.5; bare Node 42.8 | 428% | 68% | 0 | 0 |
| template | --help |
default | 106.8 (137.7) | 16.8 (20.1) | — | — | — | 0 | 0 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| real | receipts --json |
git | 212.1 (276.3) | 87.8 (150.0) | 27.3 | 776% | 321% | 3 | 3 |
| real | receipts --json |
native | 126.1 (127.7) | 37.1 (38.1) | 27.9 | 452% | 133% | 0 | 0 |
| real | provenance --all --json |
git | 3651.0 (4213.4) | 2292.2 (2702.0) | 27.6 | 13214% | 8296% | 102 | 102 |
| real | provenance --all --json |
native | 3413.4 (3653.9) | 2138.2 (2237.9) | 27.5 | 12394% | 7764% | 99 | 99 |
| real | resolve list --json |
git | 167.6 (232.5) | 52.1 (110.8) | 26.2 | 640% | 199% | 2 | 2 |
| real | resolve list --json |
native | 114.2 (117.1) | 22.8 (23.8) | 26.6 | 429% | 86% | 0 | 0 |
| real | metadata status --json |
git | 510.3 (630.9) | 277.9 (338.9) | — | — | — | 10 | 10 |
| real | metadata status --json |
native | 349.5 (359.1) | 154.7 (219.0) | — | — | — | 3 | 3 |
| real | metadata validate --json |
git | 515.9 (571.7) | 221.1 (279.7) | — | — | — | 10 | 10 |
| real | metadata validate --json |
native | 296.0 (353.2) | 154.9 (210.0) | — | — | — | 3 | 3 |
| real | audit identity --json |
git | 256.6 (360.2) | 116.5 (178.2) | — | — | — | 4 | 4 |
| real | audit identity --json |
native | 172.8 (232.0) | 68.4 (126.9) | — | — | — | 1 | 1 |
| real | graph |
git | 308.4 (371.4) | 122.6 (177.5) | 44.9 | 686% | 273% | 4 | 4 |
| real | graph |
native | 169.8 (177.0) | 66.8 (72.9) | 45.0 | 378% | 149% | 1 | 1 |
| scale | receipts --json |
git | 218.8 (334.0) | 88.4 (148.4) | 27.0 | 810% | 327% | 3 | 3 |
| scale | receipts --json |
native | 153.7 (162.2) | 60.9 (65.9) | 27.6 | 556% | 221% | 0 | 0 |
| scale | provenance --all --json |
git | 246.4 (309.8) | 111.3 (174.5) | 27.2 | 907% | 410% | 4 | 4 |
| scale | provenance --all --json |
native | 183.5 (241.3) | 80.3 (139.5) | 27.6 | 665% | 291% | 1 | 1 |
| scale | resolve list --json |
git | 256.1 (335.1) | 93.7 (152.1) | 29.9 | 858% | 314% | 3 | 3 |
| scale | resolve list --json |
native | 198.6 (253.7) | 94.5 (151.1) | 31.7 | 626% | 298% | 0 | 0 |
| scale | metadata status --json |
git | 652.0 (661.1) | 373.6 (385.1) | — | — | — | 14 | 14 |
| scale | metadata status --json |
native | 499.7 (549.9) | 337.2 (395.1) | — | — | — | 3 | 3 |
| scale | metadata validate --json |
git | 692.0 (899.8) | 376.1 (449.2) | — | — | — | 14 | 14 |
| scale | metadata validate --json |
native | 544.8 (562.0) | 334.5 (406.3) | — | — | — | 3 | 3 |
| scale |
audit identity --json (exits 1) |
git | 290.9 (339.2) | 141.2 (149.2) | — | — | — | 4 | 4 |
| scale |
audit identity --json (exits 1) |
native | 220.7 (280.7) | 115.9 (175.0) | — | — | — | 1 | 1 |
| scale | graph |
git | 270.2 (387.7) | 125.7 (185.9) | 69.3 | 390% | 182% | 4 | 4 |
| scale | graph |
native | 205.2 (263.7) | 99.3 (158.7) | 69.5 | 295% | 143% | 1 | 1 |
| real | capabilities --json |
git | 174.9 (232.5) | 55.3 (116.3) | — | — | — | 2 | 2 |
| real | capabilities --json |
native | 153.0 (158.8) | 42.7 (46.5) | — | — | — | 1 | 1 |
| real | doctor --json |
git | 169.0 (226.1) | 51.0 (111.1) | — | — | — | 2 | 2 |
| real | doctor --json |
native | 146.4 (207.3) | 40.5 (98.8) | — | — | — | 1 | 1 |
| scale | workspace list |
git | 346.7 (414.2) | 403.5 (489.7) | 30.1 | 1153% | 1342% | 5 | 5 |
| scale | workspace list |
native | 320.2 (381.1) | 383.4 (443.4) | 30.1 | 1063% | 1273% | 4 | 4 |
| template | merge-plan feature --json |
git | 490.9 (617.5) | 268.8 (327.4) | 30.6 | 1604% | 878% | 9 | 9 |
| template | merge-plan feature --json |
native | 463.3 (521.4) | 204.4 (258.7) | 30.8 | 1504% | 664% | 7 | 7 |
| template | rebase-plan main feature --json |
git | 531.7 (660.5) | 291.4 (347.7) | 31.0 | 1715% | 940% | 10 | 10 |
| template | rebase-plan main feature --json |
native | 492.6 (499.9) | 218.9 (279.9) | 30.6 | 1611% | 716% | 8 | 8 |
| template | proof-bundle feature |
git | 1024.1 (1077.6) | 585.9 (628.4) | — | — | — | 26 | 26 |
| template | proof-bundle feature |
native | 797.2 (966.9) | 468.8 (534.5) | — | — | — | 15 | 15 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | commit |
default | 671.9 (957.3) | 417.0 (482.4) | 68.3 | 983% | 610% | 15 | 15 |
| template | merge --compact feature |
default | 1580.6 (2581.5) | 1586.5 (2065.4) | 102.0 | 1550% | 1556% | 40 | 40 |
| template | cherry-pick <feature tip> |
default | 1388.1 (1927.2) | 1379.2 (1805.8) | 54.1 | 2568% | 2551% | 35 | 35 |
| template | forecast feature (worktree engine) |
default | 983.9 (1159.0) | 995.8 (1241.7) | 35.0 | 2809% | 2843% | 18 | 18 |
| template | forecast feature (merge-tree engine) |
default | 681.2 (793.8) | 700.3 (868.8) | 35.4 | 1924% | 1978% | 12 | 12 |
| template | reconcile feature |
default | 3712.7 (6182.3) | 3770.0 (4542.8) | 100.4 | 3697% | 3754% | 101 | 101 |
| template | rebase main (from feature) |
default | 4062.6 (4689.8) | 4135.9 (6514.1) | 176.4 | 2303% | 2345% | 110 | 110 |
| template | workspace create |
default | 293.7 (404.2) | 298.6 (412.8) | 102.0 | 288% | 293% | 3 | 3 |
| template | metadata export |
default | 1425.6 (1773.0) | 846.9 (1159.6) | — | — | — | 34 | 34 |
| template | spec index specs/design.md |
default | 173.9 (234.5) | 184.9 (243.0) | — | — | — | 2 | 2 |
Every entry here still delegates, and none exceeds both sides' IQR (see Findings).
- scale
workspace list[git]: rust 403.47 ms vs js 346.74 ms - scale
workspace list[native]: rust 383.41 ms vs js 320.17 ms - template
merge --compact feature[default]: rust 1586.49 ms vs js 1580.57 ms - template
forecast feature (worktree engine)[default]: rust 995.83 ms vs js 983.93 ms - template
forecast feature (merge-tree engine)[default]: rust 700.34 ms vs js 681.22 ms - template
reconcile feature[default]: rust 3770 ms vs js 3712.73 ms - template
rebase main (from feature)[default]: rust 4135.95 ms vs js 4062.55 ms - template
workspace create[default]: rust 298.57 ms vs js 293.7 ms - template
spec index specs/design.md[default]: rust 184.93 ms vs js 173.9 ms
Part B times in-process phases of the JavaScript modules, so the Rust CLI does not enter it; it is recorded for continuity. This is a regression check against hosts.lab-windows-a (the 2026-09-19 baseline). The verdict is no regression: every process count is unchanged (forecast worktree-ordinary 63, worktree-session 23, merge-tree-session 9; publication 139), and every median is within tolerance. Node startup is excluded from both sides:
| Phase | cst | Plain Git | Ratio | Processes, cst / Git |
|---|---|---|---|---|
history |
38.64 ms | 36.85 ms | 105% | 1 / 1 |
gitWorktrees |
31.13 ms | 36.22 ms | 86% | 1 / 1 |
workspaceStatus |
201.59 ms | 129.86 ms | 155% | 4 / 4 |
noteCatalog |
67.47 ms | 68.06 ms | 99% | 2 / 2 |
resolutionCatalog |
98.02 ms | 61.23 ms | 160% | 2 / 2 |
metadataStatus |
388.74 ms | 192.15 ms | 202% | 9 / 6 |
workspaceCreate |
405.88 ms | 359.20 ms | 113% | 2 / 1 |
workspaceCreateCone |
228.37 ms | 165.15 ms | 138% | 4 / 3 |
Forecast totals were: worktree (ordinary) 2,965 ms; worktree with the session 1,593 ms; merge-tree with the session 585 ms. These are 33% to 47% above checkpoint 2, within tolerance, and track the busier host (see Findings).
The clone is at v0.18.0 with notes 4089785 (146 accepted records, no resolutions), in the controlled environment, fetched as the corrected step 5 says. The Git and native engines gave identical domain and CLI results, and the repository was unchanged. Its whole-CLI column runs node bin/vlab.js, not the Rust CLI. Times are median / p95 (the maximum of nine samples):
| Phase | Git engine, phase | Native, phase | Raw-Git floor | Git engine, whole CLI | Native, whole CLI | Git processes, Git / native |
|---|---|---|---|---|---|---|
noteCatalog |
104.3 / 162.7 | 47.2 / 71.6 | — | 203.4 / 260.8 | 144.6 / 205.9 | 3 / 0 |
resolutionCatalog |
62.4 / 121.9 | 36.2 / 98.2 | 61.0 / 185.5 | 160.0 / 218.9 | 131.4 / 192.0 | 2 / 0 |
metadataStatus |
409.1 / 472.8 | 221.7 / 279.1 | — | 513.4 / 534.1 | 318.0 / 376.8 | 10 / 3 |
-
The two metadata writes Part A measures now run natively, and both are faster:
-
commit(with--generated-by, so through the notes lock and the note and retention carriers) takes 417.0 ms against 671.9 ms, 0.62 of the JavaScript CLI; -
metadata exporttakes 846.9 ms against 1,425.6 ms, 0.59; - both launch exactly the JavaScript CLI's Git processes (15 and 34).
The other #145 writes (
init,metadata retain,importanddispose) are not in the harness's command list. They are qualified for parity in all six modes on #145's pull requests. -
-
The ported reads hold their checkpoint 2 gains: 0.20 to 0.67 of the JavaScript CLI's time across the 38 native read measurements, with a geometric mean of 0.44 (0.43 at checkpoint 2).
-
Git process counts are identical to the JavaScript CLI on all 52 measurements.
-
Every delegated command is within noise. The harness lists nine as slower; none exceeds both sides' IQR, so no optimization issue is filed. The largest is
workspace liston the scale fixture: +57 to +63 ms against IQRs of about 60 ms on both sides. -
This host was noisier than at checkpoint 2. The median IQR of the read measurements doubled (24.8 to 58.8 ms), and Part B's forecast totals rose by a third. The Expo dev server is the one new background load. The JavaScript CLI's reads moved by a median of only +3%, so compare the
rustandjscolumns within this run, and treat cross-checkpoint milliseconds with that noise in mind. -
Optimization issues: none filed.
Measured with this procedure at 386d17c (#144 completed through PR #186), in a clean detached checkout, with the Rust CLI built in release mode at the same commit (native/target/release/cst.exe). At this checkpoint the Rust CLI answers every command #144 lists natively: doctor, capabilities, graph, receipts, provenance, metadata status and validate, audit identity, resolve list and status, spec show and status, merge-plan, rebase-plan, proof-bundle and verify-proof. It still delegates workspace list and every write. Host conditions: the Balanced power plan, Defender real-time protection on, and idle Claude Code and Codex sessions in the background. No game or suite was running.
Comparability. The Part A harness hash changed since checkpoint 1 (a29f59a5f2ec, was 2131c6c1abbe), but only through the #159 renames:
- environment selectors set both
CAUSET_*andVLAB_*; - the trace prefix is matched as
cstorvlab; - each floor reads the notes names its fixture holds;
- the binding file is
causet-core.node.
The commands, fixtures, statistics and environment are unchanged, so checkpoint 1's figures stay comparable.
Deviation in Part C. Step 5's fetch of refs/notes/* now also brings refs/notes/causet from the migrated source checkout, and the current build would read it in place of the pinned refs/notes/vcs-lab. That ref was deleted from the clone before measuring, so the clone holds what Part A's real fixture holds. Step 5 now fetches only refs/notes/vcs-lab.
-
Host:
lab-windows-a, AMD Ryzen 7 5800X3D 8-Core Processor, 16 logical CPUs, 32 GiB, Windows_NT 10.0.26300 -
Versions: Node v26.4.0, git version 2.55.0.windows.3, rustc 1.98.1. Source
386d17c, harnessa29f59a5f2ec -
Implementations:
js(causet 0.20.0),rust(causet 0.20.0) -
Native binding: available (
83b6ec32006a) - Sampling: 21 timed samples after 3 warm-ups, interleaved across sides. Whole-process wall time
- Load: start 5% CPU (max 11%) / 8.3 GiB free; after fixtures 13% CPU (max 18%) / 8.3 GiB free; end 13% CPU (max 13%) / 11.0 GiB free. Note: Balanced power plan; Defender real-time protection on; background: idle Claude Code and Codex sessions
-
Fixtures:
template: deterministic repository: 32 commits on main (52 across all refs, including notes), one compact landing with receipts and carried provenance, a feature branch of 4 vlab commits diverged by 3, a 12-section Markdown spec (52 commits);real: --no-local clone of this repository at v0.18.0 with refs/notes/vcs-lab pinned to 4089785 and refs/vcs-lab/* from the source (237 commits);scale: synthetic scale fixture, profile reduced-local-v3: 100 commits, 4 workspaces, 60 causal notes, 12 resolutions, 600 files - Equality: every deterministic read printed identical bytes across samples, engines and implementations
- Duration: 1730 s
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | --version |
default | 106.4 (116.1) | 15.9 (44.4) | 23.5; bare Node 41.3 | 452% | 68% | 0 | 0 |
| template | --help |
default | 103.4 (105.0) | 15.7 (16.8) | — | — | — | 0 | 0 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| real | receipts --json |
git | 226.8 (232.6) | 80.5 (104.2) | 27.3 | 831% | 295% | 3 | 3 |
| real | receipts --json |
native | 124.7 (149.6) | 30.2 (37.1) | 27.0 | 462% | 112% | 0 | 0 |
| real | provenance --all --json |
git | 3267.7 (3475.7) | 2051.2 (2157.1) | 26.8 | 12216% | 7668% | 102 | 102 |
| real | provenance --all --json |
native | 3234.5 (3764.2) | 2053.6 (2253.8) | 27.0 | 11962% | 7595% | 99 | 99 |
| real | resolve list --json |
git | 162.9 (187.9) | 51.3 (53.7) | 25.3 | 644% | 203% | 2 | 2 |
| real | resolve list --json |
native | 114.2 (138.6) | 22.2 (48.6) | 25.5 | 447% | 87% | 0 | 0 |
| real | metadata status --json |
git | 469.5 (524.8) | 217.9 (262.7) | — | — | — | 10 | 10 |
| real | metadata status --json |
native | 293.6 (322.6) | 152.9 (180.4) | — | — | — | 3 | 3 |
| real | metadata validate --json |
git | 470.9 (514.5) | 211.9 (236.5) | — | — | — | 10 | 10 |
| real | metadata validate --json |
native | 298.2 (334.5) | 151.7 (176.2) | — | — | — | 3 | 3 |
| real | audit identity --json |
git | 247.2 (271.9) | 107.5 (133.5) | — | — | — | 4 | 4 |
| real | audit identity --json |
native | 167.8 (171.6) | 60.1 (61.8) | — | — | — | 1 | 1 |
| real | graph |
git | 266.7 (270.8) | 109.1 (132.1) | 43.4 | 615% | 252% | 4 | 4 |
| real | graph |
native | 166.8 (192.8) | 59.1 (84.5) | 43.5 | 384% | 136% | 1 | 1 |
| scale | receipts --json |
git | 214.0 (237.5) | 83.8 (90.5) | 26.3 | 814% | 319% | 3 | 3 |
| scale | receipts --json |
native | 152.3 (156.3) | 58.4 (60.1) | 26.9 | 565% | 217% | 0 | 0 |
| scale | provenance --all --json |
git | 241.6 (269.4) | 107.7 (133.3) | 26.0 | 929% | 414% | 4 | 4 |
| scale | provenance --all --json |
native | 182.5 (207.5) | 78.9 (85.0) | 26.3 | 693% | 300% | 1 | 1 |
| scale | resolve list --json |
git | 271.1 (321.8) | 88.3 (114.5) | 28.8 | 942% | 307% | 3 | 3 |
| scale | resolve list --json |
native | 191.4 (193.8) | 91.4 (92.8) | 29.1 | 657% | 314% | 0 | 0 |
| scale | metadata status --json |
git | 614.3 (643.1) | 334.6 (342.0) | — | — | — | 14 | 14 |
| scale | metadata status --json |
native | 487.5 (510.7) | 327.5 (350.7) | — | — | — | 3 | 3 |
| scale | metadata validate --json |
git | 610.1 (708.0) | 334.0 (385.5) | — | — | — | 14 | 14 |
| scale | metadata validate --json |
native | 508.5 (528.7) | 330.4 (354.3) | — | — | — | 3 | 3 |
| scale |
audit identity --json (exits 1) |
git | 297.5 (321.3) | 137.6 (161.6) | — | — | — | 4 | 4 |
| scale |
audit identity --json (exits 1) |
native | 216.9 (229.2) | 110.5 (119.2) | — | — | — | 1 | 1 |
| scale | graph |
git | 282.0 (314.1) | 121.2 (145.0) | 68.4 | 412% | 177% | 4 | 4 |
| scale | graph |
native | 204.2 (228.7) | 94.2 (121.0) | 68.3 | 299% | 138% | 1 | 1 |
| real | capabilities --json |
git | 176.8 (198.0) | 53.0 (77.6) | — | — | — | 2 | 2 |
| real | capabilities --json |
native | 150.4 (153.0) | 40.8 (41.8) | — | — | — | 1 | 1 |
| real | doctor --json |
git | 161.8 (192.9) | 49.3 (71.0) | — | — | — | 2 | 2 |
| real | doctor --json |
native | 143.2 (169.5) | 39.2 (65.0) | — | — | — | 1 | 1 |
| scale | workspace list |
git | 360.6 (379.1) | 345.7 (393.9) | 29.1 | 1239% | 1188% | 5 | 5 |
| scale | workspace list |
native | 316.7 (344.3) | 321.2 (352.3) | 29.2 | 1084% | 1100% | 4 | 4 |
| template | merge-plan feature --json |
git | 450.1 (487.3) | 205.6 (253.8) | 29.9 | 1507% | 689% | 9 | 9 |
| template | merge-plan feature --json |
native | 420.5 (443.7) | 194.3 (219.6) | 29.5 | 1427% | 659% | 7 | 7 |
| template | rebase-plan main feature --json |
git | 489.2 (545.0) | 251.3 (280.4) | 29.7 | 1649% | 847% | 10 | 10 |
| template | rebase-plan main feature --json |
native | 450.8 (466.1) | 215.5 (239.2) | 29.7 | 1520% | 727% | 8 | 8 |
| template | proof-bundle feature |
git | 957.7 (982.9) | 538.9 (585.7) | — | — | — | 26 | 26 |
| template | proof-bundle feature |
native | 745.9 (823.9) | 428.2 (482.5) | — | — | — | 15 | 15 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | commit |
default | 612.0 (693.2) | 625.6 (753.3) | 66.8 | 915% | 936% | 15 | 15 |
| template | merge --compact feature |
default | 1446.7 (1645.3) | 1441.4 (1546.4) | 99.5 | 1455% | 1449% | 40 | 40 |
| template | cherry-pick <feature tip> |
default | 1241.7 (1473.9) | 1226.0 (1434.9) | 53.7 | 2314% | 2285% | 35 | 35 |
| template | forecast feature (worktree engine) |
default | 934.4 (1081.1) | 934.5 (1091.2) | 34.1 | 2743% | 2743% | 18 | 18 |
| template | forecast feature (merge-tree engine) |
default | 637.8 (707.1) | 645.0 (702.8) | 34.1 | 1872% | 1893% | 12 | 12 |
| template | reconcile feature |
default | 3375.0 (3704.1) | 3422.1 (3996.3) | 98.6 | 3423% | 3471% | 101 | 101 |
| template | rebase main (from feature) |
default | 3670.1 (4180.4) | 3744.3 (4605.5) | 173.7 | 2113% | 2156% | 110 | 110 |
| template | workspace create |
default | 286.9 (331.0) | 313.6 (328.7) | 101.4 | 283% | 309% | 3 | 3 |
| template | metadata export |
default | 1262.1 (1352.7) | 1264.0 (1372.5) | — | — | — | 34 | 34 |
| template | spec index specs/design.md |
default | 169.9 (198.9) | 178.4 (206.0) | — | — | — | 2 | 2 |
Every entry here is still delegated, and none exceeds both sides' IQR (see Findings).
- scale
workspace list[native]: rust 321.21 ms vs js 316.7 ms - template
commit[default]: rust 625.6 ms vs js 611.95 ms - template
forecast feature (worktree engine)[default]: rust 934.47 ms vs js 934.42 ms - template
forecast feature (merge-tree engine)[default]: rust 644.95 ms vs js 637.79 ms - template
reconcile feature[default]: rust 3422.13 ms vs js 3375 ms - template
rebase main (from feature)[default]: rust 3744.29 ms vs js 3670.1 ms - template
workspace create[default]: rust 313.56 ms vs js 286.89 ms - template
metadata export[default]: rust 1263.97 ms vs js 1262.11 ms - template
spec index specs/design.md[default]: rust 178.39 ms vs js 169.89 ms
Part B times in-process phases of the JavaScript modules, so the Rust CLI does not enter it; it is recorded for continuity. This is a regression check against hosts.lab-windows-a (the 2026-09-19 baseline). The verdict is no regression: every process count is unchanged (forecast worktree-ordinary 63, worktree-session 23, merge-tree-session 9; publication 139), and every median is within tolerance. Node startup is excluded from both sides:
| Phase | cst | Plain Git | Ratio | Processes, cst / Git |
|---|---|---|---|---|
history |
36.41 ms | 35.38 ms | 103% | 1 / 1 |
gitWorktrees |
30.68 ms | 38.19 ms | 80% | 1 / 1 |
workspaceStatus |
128.31 ms | 130.95 ms | 98% | 4 / 4 |
noteCatalog |
75.85 ms | 68.75 ms | 110% | 2 / 2 |
resolutionCatalog |
100.62 ms | 57.67 ms | 174% | 2 / 2 |
metadataStatus |
347.02 ms | 193.42 ms | 179% | 9 / 6 |
workspaceCreate |
404.70 ms | 366.10 ms | 111% | 2 / 1 |
workspaceCreateCone |
225.19 ms | 160.50 ms | 140% | 4 / 3 |
Forecast totals were: worktree (ordinary) 2,168 ms; worktree with the session 1,071 ms; merge-tree with the session 416 ms. workspaceRegistry (0.41 ms) has no plain-Git equivalent.
The clone is at v0.18.0 with notes 4089785 (146 accepted records, no resolutions), in the controlled environment, with refs/notes/causet removed as described above. The Git and native engines gave identical domain and CLI results, and the repository was unchanged. Its whole-CLI column runs node bin/vlab.js, not the Rust CLI. The script is unchanged since checkpoint 1 (8d7be7aa56c7). Times are median / p95 (the maximum of nine samples):
| Phase | Git engine, phase | Native, phase | Raw-Git floor | Git engine, whole CLI | Native, whole CLI | Git processes, Git / native |
|---|---|---|---|---|---|---|
noteCatalog |
101.9 / 128.0 | 47.4 / 73.5 | — | 200.5 / 230.7 | 147.0 / 169.4 | 3 / 0 |
resolutionCatalog |
58.9 / 86.6 | 34.5 / 62.1 | 58.0 / 86.1 | 155.5 / 212.4 | 131.0 / 161.7 | 2 / 0 |
metadataStatus |
395.4 / 466.9 | 222.0 / 248.0 | — | 476.3 / 644.9 | 308.0 / 360.0 | 10 / 3 |
-
Every ported read is faster in Rust, by 1.5× to 5×. Across the 38 native read measurements, the Rust median is 0.19 to 0.67 of the JavaScript CLI's, with a geometric mean of 0.43.
- The largest gains are on the short reads, where Node's ~100 ms startup dominated. Real
resolve list --json(native engine) takes 22.2 ms against 114.2 ms, which is 87% of the Git floor: faster than the onegit for-each-refit replaces. Realreceipts --json(native) takes 30.2 ms, 112% of its floor. - The smallest gains are where Git dominates. Real
provenance --all --jsontakes 2,051 ms against 3,268 ms; it still launches 102 Git processes on both sides, so its remaining cost is Git, not the CLI. - The planners and the proof bundle take about half their JavaScript time:
merge-plan0.46,rebase-plan0.48 to 0.51,proof-bundle0.56 to 0.57.
- The largest gains are on the short reads, where Node's ~100 ms startup dominated. Real
-
Git process counts are identical to the JavaScript CLI on all 52 measurements. Parity holds in work done, not only in output. Process counts are reported, not part of parity (ADR-0037).
-
Delegated commands are within noise.
workspace listand the ten writes still delegate. Their Rust-minus-JS medians range from −15.7 to +74.2 ms (median +7.2 ms), and none exceeds both sides' IQR, so no optimization issue is filed. Each later port removes the delegation cost for its commands. -
#165 is resolved. Its three measurements are now native and far faster than the JavaScript CLI:
- real
resolve list --json[native]: 22.2 against 114.2 ms; - scale
resolve list --json[native]: 91.4 against 191.4 ms; - scale
audit identity --json[native]: 110.5 against 216.9 ms.
- real
-
Both CLIs launch one more Git process than at checkpoint 1 on several reads under the Git engine. For example:
- real
receipts --json[git]: 3, was 2; - real
graph[git]: 4, was 3; - Part C
noteCatalog: 3, was 2.
The extra process is the
git rev-parsebehindrepoContext. #159's name resolution (repositoryNames) now runs it in commands that did not need the context before. It is the same in both implementations, costs about 29 ms on this host under the Git engine, and costs no process under the native engine. Part B's phases do not include it, and report no regression. - real
-
The JavaScript CLI measured within a few percent of checkpoint 1, with the same fixtures. For example:
- real
metadata status --json[git]: 504 → 470 ms; -
reconcile: 3,703 → 3,375 ms.
This host had more free memory (8.3 GiB against 5.7 GiB).
- real
-
Optimization issues: none filed.
Measured with this procedure at 1e61159 (#141 landed through PR #164), in a clean detached checkout, with the Rust CLI built in release mode at the same commit (native/target/release/cst.exe). At this checkpoint the Rust CLI answers --version and --help natively and delegates every other command, whole, to node bin/vlab.js. Host conditions: the Balanced power plan, Defender real-time protection on, and background load from a Claude Code session. No game or suite was running. The harness is unchanged since checkpoint 0 (2131c6c1abbe), so Part A is comparable.
-
Host:
lab-windows-a, AMD Ryzen 7 5800X3D 8-Core Processor, 16 logical CPUs, 32 GiB, Windows_NT 10.0.26200 -
Versions: Node v26.4.0, git version 2.55.0.windows.3. Source
1e61159, harness2131c6c1abbe -
Implementations:
js(causet 0.19.1),rust(causet 0.19.1) -
Native binding: available (
3bf5dc5de3ce) - Sampling: 21 timed samples after 3 warm-ups, interleaved across sides. Whole-process wall time
- Load: start 19% CPU (max 30%) / 5.7 GiB free; after fixtures 23% CPU (max 28%) / 5.5 GiB free; end 22% CPU (max 29%) / 6.3 GiB free. Note: Balanced power plan; Defender real-time protection on; background: Claude Code session
-
Fixtures:
template: deterministic repository: 32 commits on main (52 across all refs, including notes), one compact landing with receipts and carried provenance, a feature branch of 4 vlab commits diverged by 3, a 12-section Markdown spec (52 commits);real: --no-local clone of this repository at v0.18.0 with refs/notes/vcs-lab pinned to 4089785 and refs/vcs-lab/* from the source (237 commits);scale: synthetic scale fixture, profile reduced-local-v3: 100 commits, 4 workspaces, 60 causal notes, 12 resolutions, 600 files - Equality: every deterministic read printed identical bytes across samples, engines and implementations
- Duration: 2051 s
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | --version |
default | 104.6 (108.5) | 16.6 (17.5) | 25.9; bare Node 43.6 | 404% | 64% | 0 | 0 |
| template | --help |
default | 103.2 (108.5) | 15.8 (16.9) | — | — | — | 0 | 0 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| real | receipts --json |
git | 186.5 (215.8) | 195.6 (236.0) | 28.5 | 654% | 686% | 2 | 2 |
| real | receipts --json |
native | 123.2 (151.6) | 131.0 (155.4) | 29.1 | 423% | 450% | 0 | 0 |
| real | provenance --all --json |
git | 3453.4 (3875.6) | 3449.1 (3910.8) | 28.6 | 12079% | 12064% | 101 | 101 |
| real | provenance --all --json |
native | 3370.2 (3916.8) | 3392.8 (3889.7) | 28.9 | 11666% | 11744% | 99 | 99 |
| real | resolve list --json |
git | 134.6 (168.2) | 147.0 (173.1) | 26.9 | 500% | 546% | 1 | 1 |
| real | resolve list --json |
native | 108.7 (112.4) | 119.4 (144.9) | 27.3 | 398% | 437% | 0 | 0 |
| real | metadata status --json |
git | 503.9 (587.2) | 501.7 (541.9) | — | — | — | 10 | 10 |
| real | metadata status --json |
native | 263.4 (290.7) | 279.7 (298.9) | — | — | — | 3 | 3 |
| real | metadata validate --json |
git | 483.8 (530.1) | 495.1 (550.0) | — | — | — | 10 | 10 |
| real | metadata validate --json |
native | 265.9 (311.2) | 276.7 (323.6) | — | — | — | 3 | 3 |
| real | audit identity --json |
git | 259.9 (287.9) | 281.3 (307.4) | — | — | — | 4 | 4 |
| real | audit identity --json |
native | 167.4 (195.9) | 173.5 (201.2) | — | — | — | 1 | 1 |
| real | graph |
git | 225.2 (251.9) | 247.7 (266.5) | 45.4 | 495% | 545% | 3 | 3 |
| real | graph |
native | 165.6 (195.9) | 172.9 (209.2) | 45.3 | 366% | 382% | 1 | 1 |
| scale | receipts --json |
git | 185.0 (191.6) | 217.5 (231.9) | 28.1 | 657% | 773% | 2 | 2 |
| scale | receipts --json |
native | 152.8 (160.9) | 163.3 (187.9) | 29.3 | 522% | 557% | 0 | 0 |
| scale | provenance --all --json |
git | 221.6 (254.1) | 234.9 (326.9) | 28.1 | 790% | 837% | 3 | 3 |
| scale | provenance --all --json |
native | 183.0 (216.4) | 196.4 (222.1) | 29.0 | 630% | 677% | 1 | 1 |
| scale | resolve list --json |
git | 257.1 (282.2) | 267.1 (332.6) | 31.0 | 829% | 861% | 3 | 3 |
| scale | resolve list --json |
native | 164.8 (173.7) | 175.3 (198.7) | 31.1 | 529% | 563% | 0 | 0 |
| scale | metadata status --json |
git | 639.3 (733.1) | 657.0 (741.3) | — | — | — | 14 | 14 |
| scale | metadata status --json |
native | 401.2 (424.9) | 415.6 (444.4) | — | — | — | 3 | 3 |
| scale | metadata validate --json |
git | 646.9 (709.2) | 643.4 (708.8) | — | — | — | 14 | 14 |
| scale | metadata validate --json |
native | 405.6 (452.4) | 423.9 (465.6) | — | — | — | 3 | 3 |
| scale |
audit identity --json (exits 1) |
git | 301.6 (332.6) | 296.9 (333.4) | — | — | — | 4 | 4 |
| scale |
audit identity --json (exits 1) |
native | 218.8 (248.6) | 229.2 (253.7) | — | — | — | 1 | 1 |
| scale | graph |
git | 239.9 (275.3) | 249.8 (275.6) | 74.9 | 320% | 333% | 3 | 3 |
| scale | graph |
native | 209.4 (229.8) | 214.8 (258.4) | 73.9 | 283% | 291% | 1 | 1 |
| real | capabilities --json |
git | 176.1 (204.7) | 186.7 (216.1) | — | — | — | 2 | 2 |
| real | capabilities --json |
native | 151.3 (160.5) | 163.5 (194.3) | — | — | — | 1 | 1 |
| real | doctor --json |
git | 165.8 (205.8) | 173.8 (209.6) | — | — | — | 2 | 2 |
| real | doctor --json |
native | 139.7 (167.1) | 147.2 (181.6) | — | — | — | 1 | 1 |
| scale | workspace list |
git | 363.0 (407.8) | 366.7 (437.8) | 31.9 | 1139% | 1150% | 5 | 5 |
| scale | workspace list |
native | 340.1 (365.6) | 355.1 (381.4) | 31.3 | 1086% | 1134% | 4 | 4 |
| template | merge-plan feature --json |
git | 474.7 (522.3) | 474.5 (525.9) | 32.2 | 1476% | 1475% | 9 | 9 |
| template | merge-plan feature --json |
native | 420.2 (455.6) | 444.3 (489.4) | 32.0 | 1313% | 1388% | 7 | 7 |
| template | rebase-plan main feature --json |
git | 500.9 (531.0) | 517.7 (563.9) | 31.8 | 1576% | 1628% | 10 | 10 |
| template | rebase-plan main feature --json |
native | 461.8 (488.3) | 463.6 (518.6) | 31.3 | 1478% | 1484% | 8 | 8 |
| template | proof-bundle feature |
git | 1045.2 (1165.8) | 1067.7 (1129.3) | — | — | — | 26 | 26 |
| template | proof-bundle feature |
native | 793.6 (864.5) | 785.1 (862.9) | — | — | — | 15 | 15 |
| Fixture | Command | Engine | js median (p90) | rust median (p90) | Git floor | js / floor | rust / floor | js Git processes | rust Git processes |
|---|---|---|---|---|---|---|---|---|---|
| template | commit |
default | 675.1 (844.4) | 673.5 (780.6) | 73.8 | 915% | 912% | 15 | 15 |
| template | merge --compact feature |
default | 1583.8 (1803.9) | 1600.0 (1971.1) | 111.0 | 1427% | 1441% | 40 | 40 |
| template | cherry-pick <feature tip> |
default | 1320.5 (1725.5) | 1353.7 (1600.6) | 58.3 | 2265% | 2322% | 35 | 35 |
| template | forecast feature (worktree engine) |
default | 1026.1 (1081.8) | 1033.0 (1157.6) | 36.4 | 2817% | 2836% | 18 | 18 |
| template | forecast feature (merge-tree engine) |
default | 677.6 (735.7) | 676.8 (760.1) | 36.3 | 1868% | 1866% | 12 | 12 |
| template | reconcile feature |
default | 3702.9 (4165.6) | 3742.1 (4018.1) | 107.0 | 3462% | 3499% | 101 | 101 |
| template | rebase main (from feature) |
default | 4180.8 (5103.1) | 4081.0 (4396.7) | 184.6 | 2265% | 2211% | 110 | 110 |
| template | workspace create |
default | 310.4 (367.9) | 323.8 (417.2) | 112.3 | 276% | 288% | 3 | 3 |
| template | metadata export |
default | 1366.2 (1510.2) | 1369.3 (1636.1) | — | — | — | 34 | 34 |
| template | spec index specs/design.md |
default | 179.6 (212.3) | 196.3 (231.8) | — | — | — | 2 | 2 |
Every delegated command pays the delegation process, so most appear here. Only three exceed both sides' IQR (see Findings).
- real
receipts --json[git]: rust 195.62 ms vs js 186.48 ms - real
receipts --json[native]: rust 131.01 ms vs js 123.19 ms - real
provenance --all --json[native]: rust 3392.77 ms vs js 3370.17 ms - real
resolve list --json[git]: rust 146.96 ms vs js 134.6 ms - real
resolve list --json[native]: rust 119.39 ms vs js 108.74 ms - real
metadata status --json[native]: rust 279.74 ms vs js 263.45 ms - real
metadata validate --json[git]: rust 495.15 ms vs js 483.78 ms - real
metadata validate --json[native]: rust 276.68 ms vs js 265.9 ms - real
audit identity --json[git]: rust 281.34 ms vs js 259.89 ms - real
audit identity --json[native]: rust 173.54 ms vs js 167.4 ms - real
graph[git]: rust 247.73 ms vs js 225.15 ms - real
graph[native]: rust 172.94 ms vs js 165.58 ms - scale
receipts --json[git]: rust 217.54 ms vs js 185.01 ms - scale
receipts --json[native]: rust 163.27 ms vs js 152.82 ms - scale
provenance --all --json[git]: rust 234.9 ms vs js 221.59 ms - scale
provenance --all --json[native]: rust 196.45 ms vs js 182.99 ms - scale
resolve list --json[git]: rust 267.15 ms vs js 257.13 ms - scale
resolve list --json[native]: rust 175.31 ms vs js 164.79 ms - scale
metadata status --json[git]: rust 657.03 ms vs js 639.32 ms - scale
metadata status --json[native]: rust 415.64 ms vs js 401.23 ms - scale
metadata validate --json[native]: rust 423.89 ms vs js 405.65 ms - scale
audit identity --json[native]: rust 229.19 ms vs js 218.83 ms - scale
graph[git]: rust 249.82 ms vs js 239.9 ms - scale
graph[native]: rust 214.85 ms vs js 209.45 ms - real
capabilities --json[git]: rust 186.65 ms vs js 176.08 ms - real
capabilities --json[native]: rust 163.52 ms vs js 151.31 ms - real
doctor --json[git]: rust 173.84 ms vs js 165.76 ms - real
doctor --json[native]: rust 147.21 ms vs js 139.67 ms - scale
workspace list[git]: rust 366.71 ms vs js 363 ms - scale
workspace list[native]: rust 355.11 ms vs js 340.11 ms - template
merge-plan feature --json[native]: rust 444.31 ms vs js 420.17 ms - template
rebase-plan main feature --json[git]: rust 517.69 ms vs js 500.95 ms - template
rebase-plan main feature --json[native]: rust 463.64 ms vs js 461.84 ms - template
proof-bundle feature[git]: rust 1067.72 ms vs js 1045.18 ms - template
merge --compact feature[default]: rust 1600.03 ms vs js 1583.8 ms - template
cherry-pick <feature tip>[default]: rust 1353.69 ms vs js 1320.51 ms - template
forecast feature (worktree engine)[default]: rust 1033.03 ms vs js 1026.08 ms - template
reconcile feature[default]: rust 3742.05 ms vs js 3702.93 ms - template
workspace create[default]: rust 323.82 ms vs js 310.45 ms - template
metadata export[default]: rust 1369.35 ms vs js 1366.15 ms - template
spec index specs/design.md[default]: rust 196.27 ms vs js 179.55 ms
Part B times in-process phases of the JavaScript modules, so the Rust CLI does not enter it; it is recorded for continuity. This is a regression check against hosts.lab-windows-a (the 2026-09-19 baseline). The verdict is no regression: every process count is unchanged (forecast worktree-ordinary 63, worktree-session 23, merge-tree-session 9), and every median is within tolerance. Node startup is excluded from both sides:
| Phase | vlab | Plain Git | Ratio | Processes, vlab / Git |
|---|---|---|---|---|
history |
38.92 ms | 40.34 ms | 96% | 1 / 1 |
gitWorktrees |
34.87 ms | 40.61 ms | 86% | 1 / 1 |
workspaceStatus |
170.77 ms | 140.24 ms | 122% | 4 / 4 |
noteCatalog |
73.71 ms | 69.82 ms | 106% | 2 / 2 |
resolutionCatalog |
101.06 ms | 59.77 ms | 169% | 2 / 2 |
metadataStatus |
378.56 ms | 211.01 ms | 179% | 9 / 6 |
workspaceCreate |
446.06 ms | 384.92 ms | 116% | 2 / 1 |
workspaceCreateCone |
230.32 ms | 179.39 ms | 128% | 4 / 3 |
Forecast totals were: worktree (ordinary) 2,288 ms; worktree with the session 1,112 ms; merge-tree with the session 527 ms. workspaceRegistry (0.33 ms) has no plain-Git equivalent.
The clone is at v0.18.0 with notes 4089785 (146 accepted records, no resolutions), in the controlled environment. The Git and native engines gave identical domain and CLI results, and the repository was unchanged. Its whole-CLI column runs node bin/vlab.js, not the Rust CLI. The script changed since checkpoint 0 (8d7be7aa56c7, was 7ee0ee9c4d70), so compare these figures within this run. Times are median / p95 (the maximum of nine samples):
| Phase | Git engine, phase | Native, phase | Raw-Git floor | Git engine, whole CLI | Native, whole CLI | Git processes, Git / native |
|---|---|---|---|---|---|---|
noteCatalog |
81.1 / 111.1 | 47.4 / 76.0 | — | 178.8 / 217.8 | 148.9 / 223.3 | 2 / 0 |
resolutionCatalog |
34.6 / 70.6 | 36.1 / 71.7 | 34.3 / 64.6 | 131.1 / 157.4 | 132.4 / 161.1 | 1 / 0 |
metadataStatus |
411.2 / 473.3 | 187.1 / 221.1 | — | 487.2 / 547.8 | 301.2 / 357.2 | 10 / 3 |
-
A native answer costs less than Git's own startup.
cst --versiontakes 16.6 ms, against 104.6 ms for the JavaScript CLI, 25.9 ms forgit --versionand 43.6 ms for a barenode -e 0: 64% of the Git floor, and 6.3 times faster than the JavaScript CLI.--helpis 15.8 ms against 103.2 ms. This is the startup cost checkpoint 0 said the port would remove, measured on the first commands to go native. -
Delegation costs about one process start. Across the 50 delegated measurements the Rust CLI is a median 10.6 ms slower than the JavaScript CLI called directly. On Windows it spawns Node and waits; on POSIX it
execs Node and adds no process. Only three measurements exceed both sides' IQR, and they are the fastest, least noisy reads:resolve list --json(native) on the real and scale fixtures, andaudit identity --json(native) on scale, each about +10.5 ms. They are filed as #165, which each port removes for its own commands. The widest differences in either direction (−100 to +39 ms) are the 1.3–4 s writes, where they are well within those commands' IQRs. - Delegation changes nothing else. Git process counts are identical to the JavaScript CLI on all 52 measurements, and every deterministic read printed identical bytes across samples, engines and implementations.
-
The JavaScript CLI measured 0–12% slower than at checkpoint 0, with the same harness and fixtures (for example, real
metadata status --json[git] 464 → 504 ms). This host had 5.7 GiB free against 13.2 GiB at checkpoint 0. Part B, which checks the same phases against the committed baseline, reports no regression, so this is host state rather than a code change. Compare therustandjscolumns within this run. - Optimization issues: #165.
Measured with this procedure at c224405 (v0.18.0 plus the harness), in a clean checkout. Host conditions: the Balanced power plan, Defender real-time protection on, and background load from Orca, Claude Code sessions and SimHub. No game or suite was running. An ad-hoc baseline recorded earlier the same day, before this procedure existed, is superseded and kept in this page's history.
-
Host:
lab-windows-a, AMD Ryzen 7 5800X3D 8-Core Processor, 16 logical CPUs, 32 GiB, Windows_NT 10.0.26200 -
Versions: Node v26.4.0, git version 2.55.0.windows.3. Source
c224405, harness2131c6c1abbe -
Implementations:
js(vcs-lab 0.18.0) -
Native binding: available (
3ad6a6fbdf8f) - Sampling: 21 timed samples after 3 warm-ups, interleaved across sides. Whole-process wall time
- Load: start 14% CPU (max 22%) / 13.2 GiB free; after fixtures 26% CPU (max 34%) / 12.1 GiB free; end 19% CPU (max 22%) / 13.4 GiB free. Note: Balanced power plan; Defender real-time protection on; background: Orca, Claude Code sessions, SimHub
-
Fixtures:
template: deterministic repository: 32 commits on main (52 across all refs, including notes), one compact landing with receipts and carried provenance, a feature branch of 4 cst commits diverged by 3, a 12-section Markdown spec (52 commits);real: --no-local clone of this repository at v0.18.0 with refs/notes/vcs-lab pinned to 4089785 and refs/vcs-lab/* from the source (237 commits);scale: synthetic scale fixture, profile reduced-local-v3: 100 commits, 4 workspaces, 60 causal notes, 12 resolutions, 600 files - Equality: every deterministic read printed identical bytes across samples, engines and implementations
- Duration: 1030 s
| Fixture | Command | Engine | js median (p90) | Git floor | js / floor | js Git processes |
|---|---|---|---|---|---|---|
| template | --version |
default | 108.5 (120.2) | 26.2; bare Node 44.9 | 414% | 0 |
| template | --help |
default | 105.2 (109.0) | — | — | 0 |
| Fixture | Command | Engine | js median (p90) | Git floor | js / floor | js Git processes |
|---|---|---|---|---|---|---|
| real | receipts --json |
git | 194.1 (217.7) | 29.4 | 660% | 2 |
| real | receipts --json |
native | 123.7 (140.0) | 28.5 | 434% | 0 |
| real | provenance --all --json |
git | 3297.2 (3368.8) | 27.0 | 12194% | 101 |
| real | provenance --all --json |
native | 3195.3 (3484.4) | 27.4 | 11640% | 99 |
| real | resolve list --json |
git | 136.8 (152.1) | 26.3 | 519% | 1 |
| real | resolve list --json |
native | 110.9 (127.0) | 26.9 | 412% | 0 |
| real | metadata status --json |
git | 464.3 (554.6) | — | — | 10 |
| real | metadata status --json |
native | 257.3 (272.6) | — | — | 3 |
| real | metadata validate --json |
git | 468.4 (513.9) | — | — | 10 |
| real | metadata validate --json |
native | 256.4 (273.8) | — | — | 3 |
| real | audit identity --json |
git | 262.8 (278.7) | — | — | 4 |
| real | audit identity --json |
native | 165.8 (169.2) | — | — | 1 |
| real | graph |
git | 223.3 (239.4) | 43.0 | 519% | 3 |
| real | graph |
native | 165.1 (168.6) | 42.5 | 388% | 1 |
| scale | receipts --json |
git | 188.0 (204.8) | 27.1 | 695% | 2 |
| scale | receipts --json |
native | 151.5 (166.7) | 27.8 | 544% | 0 |
| scale | provenance --all --json |
git | 220.7 (254.3) | 27.2 | 811% | 3 |
| scale | provenance --all --json |
native | 182.5 (187.7) | 27.2 | 670% | 1 |
| scale | resolve list --json |
git | 257.9 (282.8) | 29.9 | 864% | 3 |
| scale | resolve list --json |
native | 164.1 (168.7) | 30.3 | 541% | 0 |
| scale | metadata status --json |
git | 605.4 (620.3) | — | — | 14 |
| scale | metadata status --json |
native | 402.0 (441.9) | — | — | 3 |
| scale | metadata validate --json |
git | 609.2 (631.2) | — | — | 14 |
| scale | metadata validate --json |
native | 403.8 (434.2) | — | — | 3 |
| scale |
audit identity --json (exits 1) |
git | 288.7 (295.1) | — | — | 4 |
| scale |
audit identity --json (exits 1) |
native | 224.2 (238.9) | — | — | 1 |
| scale | graph |
git | 253.4 (265.4) | 71.1 | 357% | 3 |
| scale | graph |
native | 202.4 (212.9) | 69.7 | 290% | 1 |
| real | capabilities --json |
git | 172.6 (186.3) | — | — | 2 |
| real | capabilities --json |
native | 151.6 (164.8) | — | — | 1 |
| real | doctor --json |
git | 165.6 (185.6) | — | — | 2 |
| real | doctor --json |
native | 136.5 (142.9) | — | — | 1 |
| scale | workspace list |
git | 357.4 (377.2) | 30.4 | 1175% | 5 |
| scale | workspace list |
native | 315.4 (331.4) | 30.5 | 1033% | 4 |
| template | merge-plan feature --json |
git | 451.3 (464.0) | 30.1 | 1498% | 9 |
| template | merge-plan feature --json |
native | 402.9 (415.3) | 30.4 | 1323% | 7 |
| template | rebase-plan main feature --json |
git | 504.3 (550.8) | 30.1 | 1673% | 10 |
| template | rebase-plan main feature --json |
native | 437.4 (451.3) | 30.3 | 1445% | 8 |
| template | proof-bundle feature |
git | 1006.3 (1069.3) | — | — | 26 |
| template | proof-bundle feature |
native | 736.1 (761.8) | — | — | 15 |
| Fixture | Command | Engine | js median (p90) | Git floor | js / floor | js Git processes |
|---|---|---|---|---|---|---|
| template | commit |
default | 618.0 (642.3) | 67.0 | 923% | 15 |
| template | merge --compact feature |
default | 1455.7 (1529.3) | 102.5 | 1420% | 40 |
| template | cherry-pick <feature tip> |
default | 1245.2 (1342.7) | 56.0 | 2223% | 35 |
| template | forecast feature (worktree engine) |
default | 939.4 (1007.3) | 34.8 | 2703% | 18 |
| template | forecast feature (merge-tree engine) |
default | 665.0 (717.6) | 34.6 | 1924% | 12 |
| template | reconcile feature |
default | 3491.3 (3793.7) | 102.7 | 3399% | 101 |
| template | rebase main (from feature) |
default | 3730.4 (4081.4) | 177.8 | 2099% | 110 |
| template | workspace create |
default | 291.5 (305.4) | 104.3 | 279% | 3 |
| template | metadata export |
default | 1272.6 (1342.9) | — | — | 34 |
| template | spec index specs/design.md |
default | 174.6 (183.0) | — | — | 2 |
This is a regression check against hosts.lab-windows-a (the 2026-09-19 baseline). The verdict is
no regression: every process count is unchanged (for example forecast worktree-ordinary 63,
merge-tree-session 9, publication 139), and every median is within tolerance. Node startup is
excluded from both sides:
| Phase | vlab | Plain Git | Ratio | Processes, vlab / Git |
|---|---|---|---|---|
history |
42.20 ms | 36.47 ms | 116% | 1 / 1 |
gitWorktrees |
30.84 ms | 36.04 ms | 86% | 1 / 1 |
workspaceStatus |
185.62 ms | 150.56 ms | 123% | 4 / 4 |
noteCatalog |
86.65 ms | 71.76 ms | 121% | 2 / 2 |
resolutionCatalog |
112.51 ms | 59.74 ms | 188% | 2 / 2 |
metadataStatus |
385.22 ms | 204.38 ms | 188% | 9 / 6 |
workspaceCreate |
431.10 ms | 389.48 ms | 111% | 2 / 1 |
workspaceCreateCone |
240.30 ms | 185.25 ms | 130% | 4 / 3 |
Forecast totals were: worktree (ordinary) 2,417 ms; worktree with the session 1,250 ms; merge-tree
with the session 446 ms. workspaceRegistry (0.31 ms) has no plain-Git equivalent.
The clone is at v0.18.0 with notes 4089785 (146 accepted records, no resolutions), in the controlled environment. The Git and native engines gave identical domain and CLI results, and the repository was unchanged. Times are median / p95 (the maximum of nine samples):
| Phase | Git engine, phase | Native, phase | Raw-Git floor | Git engine, whole CLI | Native, whole CLI | Git processes, Git / native |
|---|---|---|---|---|---|---|
noteCatalog |
75.9 / 146.8 | 42.9 / 65.6 | — | 167.5 / 188.0 | 142.2 / 147.7 | 2 / 0 |
resolutionCatalog |
31.4 / 45.6 | 32.1 / 46.7 | 31.1 / 48.4 | 138.1 / 160.8 | 130.7 / 143.6 | 1 / 0 |
metadataStatus |
372.6 / 423.3 | 193.8 / 202.6 | — | 473.3 / 495.9 | 284.7 / 307.7 | 10 / 3 |
-
Startup is the first cost the Rust CLI removes.
cst --versiontakes 108.5 ms, against 26.2 ms forgit --versionand 44.9 ms for a barenode -e 0. About 64 ms of that is the JavaScript CLI loading its modules before any work. Every read in Part A pays it: their Git floors are 26–30 ms, while they take 110–260 ms. -
The slowest commands are slow because of process count, not computation.
-
reconciletakes 3.5 s with 101 Git processes, andrebase3.7 s with 110, both on the small template repository.merge --compactlaunches 40,cherry-pick35, andmetadata export34. - At roughly 35 ms per Git process on this host, process count explains most of that time. A port that keeps the same process discipline keeps those costs. Batching them, which ADR-0037 now allows because process counts are reported rather than part of parity, is the largest optimization available.
-
-
provenance --all --jsonis the single worst read. On the real clone (237 commits) it takes 3.3 s and launches 101 Git processes, and 99 even with native reads, roughly one per commit. On the 100-commit scale fixture it takes 221 ms with 3 processes, so the cost follows the notes and commits it reads, not history depth alone. It is the first optimization target when #144 ports it. -
Native reads already pay off end to end.
metadata statusdrops from 464 ms to 257 ms on the real clone.resolve liston the populated scale catalog drops from 258 ms to 164 ms, andproof-bundlefrom 1,006 ms to 736 ms. -
The scale fixture's
audit identityexits 1 by design: its synthetic actors trigger findings. The status is recorded and stable across samples. - Optimization issues: none filed. Checkpoint 0 is the reference; the findings above are where a Rust implementation's optimizations should start.