Skip to content

Performance testing

Jerry Holland edited this page Nov 14, 2026 · 14 revisions

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.

Checkpoints

# 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

Procedure

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.

What a checkpoint measures

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 in detail

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 --impl the run measures the checkout's own build as rust. 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 git invocation (the "Git floor"). --version is 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. doctor is excluded because it prints timings.

  • Exit status. A read may legitimately exit non-zero to report findings (audit identity does 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=git and CAUSET_ENGINE=native. Native is skipped, and the skip recorded, when cst doctor reports 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-injected GIT_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.

1. Prepare the host

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.

  1. 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.
  2. 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 test or a benchmark. Two runs in one %TEMP% interfere with each other.
  3. Run from a checkout outside any synced folder (OneDrive, Proton Drive, Dropbox). The fixtures live under %TEMP%, which must not be synced either.
  4. 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.
  5. 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-noisy when a noisy measurement is better than none, and say so in the section.

2. Prepare the checkout

  1. Check out the exact commit under test, in a clean tree:

    git switch --detach <commit>
    git status --porcelain   # must print nothing
  2. 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), and rustc --version (the pinned toolchain).

  3. 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 (cst off Windows). Before v0.24.0 the same command also built the optional native binding.

3. Run Part A

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 on lab-windows-a at 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.

4. Run Part B

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.

5. Run Part C

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 real fixture does, and pin both before migrating. Fetching refs/notes/causet under its own name would leave the clone reading the source's latest notes in place of the pinned ones (checkpoint 2). Origin's frozen refs/notes/vcs-lab and refs/vcs-lab/retention are no longer needed (#232).
  • cst migrate is 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.

6. Check the run is valid

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 noisy is false, or the section says why a noisy run was accepted.
  • Part C reports identical results across engines.
  • git status --porcelain in the checkout is still empty.
  • No vlab-perf-*, causet-scale-benchmark-* or vlab-real directory is left in %TEMP%, unless --keep was used deliberately.

7. Record the checkpoint

  1. Paste Part A's --markdown output 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.
  2. 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.

  3. Update the checkpoint's row in the table at the top of this page.

8. Act on the results, without gating

  • 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.

  • 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).

Comparing checkpoints

  • Only compare like with like: the same host, the same power plan, the same harness (scriptSha256 in 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.

The CI companion: hosted runners

.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-a on all 52 JavaScript CLI counts, on different hardware under unknown load.
  • Ubuntu launches more processes for 16 commands, for example metadata status 13 instead of 10, and merge-plan 13 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.

Changing this procedure

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.

Checkpoints recorded

Checkpoint 9: after the cutover, the first Linux checkpoint (2026-10-17)

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 on lab-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 cst directly, 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, harness ef6551fec450
  • 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

Part A: Startup

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

Part A: Reads

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

Part A: Writes

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

Part B: Phase benchmark (npm run test:benchmark -- --host lab-linux-a)

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

Part C: Engine comparison on the real clone (scripts/measure-real-repository.mjs)

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

Findings

  • 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 list on the real clone, native engine) to 56 ms (proof-bundle), apart from provenance --all on 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.
  • The native engine is never slower, and it removes most Git processes where its catalog applies:
    • metadata status and validate go from 15 to 3 processes on the real clone, and from 19 to 3 on the scale fixture;
    • proof-bundle goes from 33 to 16 processes and from 56.4 to 42.3 ms;
    • receipts and resolve list start no Git process at all.
  • provenance --all --json on 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 (resolutionCatalog 375%, metadataStatus 299%, workspaceStatus 234%). 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-a to regress against.

Checkpoint 3: the metadata writes native (2026-10-02)

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, harness a29f59a5f2ec
  • 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

Part A: Startup

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

Part A: Reads

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

Part A: Writes

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

Part A: Slower than the JavaScript CLI (the harness's list)

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: Phase benchmark (npm run test:benchmark)

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).

Part C: Engine comparison on the real clone (scripts/measure-real-repository.mjs)

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

Findings

  • 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 export takes 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, import and dispose) 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 list on 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 rust and js columns within this run, and treat cross-checkpoint milliseconds with that noise in mind.

  • Optimization issues: none filed.

Checkpoint 2: the read-only commands native (2026-10-01)

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_* and VLAB_*;
  • the trace prefix is matched as cst or vlab;
  • 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, harness a29f59a5f2ec
  • 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

Part A: Startup

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

Part A: Reads

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

Part A: Writes

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

Part A: Slower than the JavaScript CLI (the harness's list)

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: Phase benchmark (npm run test:benchmark)

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.

Part C: Engine comparison on the real clone (scripts/measure-real-repository.mjs)

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

Findings

  • 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 one git for-each-ref it replaces. Real receipts --json (native) takes 30.2 ms, 112% of its floor.
    • The smallest gains are where Git dominates. Real provenance --all --json takes 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-plan 0.46, rebase-plan 0.48 to 0.51, proof-bundle 0.56 to 0.57.
  • 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 list and 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.
  • 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-parse behind repoContext. #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.

  • 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).

  • Optimization issues: none filed.

Checkpoint 1: the delegating skeleton (2026-09-28)

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, harness 2131c6c1abbe
  • 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

Part A: Startup

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

Part A: Reads

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

Part A: Writes

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

Part A: Slower than the JavaScript CLI (the harness's list)

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: Phase benchmark (npm run test:benchmark)

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.

Part C: Engine comparison on the real clone (scripts/measure-real-repository.mjs)

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

Findings

  • A native answer costs less than Git's own startup. cst --version takes 16.6 ms, against 104.6 ms for the JavaScript CLI, 25.9 ms for git --version and 43.6 ms for a bare node -e 0: 64% of the Git floor, and 6.3 times faster than the JavaScript CLI. --help is 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, and audit 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 the rust and js columns within this run.
  • Optimization issues: #165.

Checkpoint 0: the JavaScript CLI baseline (2026-09-27)

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, harness 2131c6c1abbe
  • 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

Part A: Startup

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

Part A: Reads

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

Part A: Writes

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

Part B: Phase benchmark (npm run test:benchmark)

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.

Part C: Engine comparison on the real clone (scripts/measure-real-repository.mjs)

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

Findings

  • Startup is the first cost the Rust CLI removes. cst --version takes 108.5 ms, against 26.2 ms for git --version and 44.9 ms for a bare node -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.
    • reconcile takes 3.5 s with 101 Git processes, and rebase 3.7 s with 110, both on the small template repository. merge --compact launches 40, cherry-pick 35, and metadata export 34.
    • 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 --json is 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 status drops from 464 ms to 257 ms on the real clone. resolve list on the populated scale catalog drops from 258 ms to 164 ms, and proof-bundle from 1,006 ms to 736 ms.
  • The scale fixture's audit identity exits 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.

Clone this wiki locally