grit://cooking/changelog← what’s cooking
Thursday, October 29, 2026 · release v0.5.25

131 changes landed on main

100 issue fixes · 31 other changes

v0.5.25 is mostly a performance and correctness release: large speedups in rebase, merge, checkout, reset, log, fetch and ref handling, plus many Git-compatibility fixes.

  • ›Faster checkout, switch, reset --hard and merge/--abort on wide trees, with much lower peak RSS
  • ›Rebase replay far faster (rename cache, delta reuse); fixes for merge commits, conflicts and --exec
  • ›Faster ref and fetch paths: reftable listing and compaction, batched receive-pack, upload-pack streaming and ACK ready
  • ›Merge uses virtual merge bases on criss-cross histories, merges on detached HEAD, and conflicts on CRLF changes
  • ›Fixes for failed-hook commits, stat/patch line counts, binary patch-text, rename similarity and patch-id
  • ›New ref-transaction concurrency, Windows reserved-name and path fixes, read-only status, and cancellation cleanup of index.lock
$ git log 29ebe004..v0.5.25319 commits on GitHub ↗300+ files +14,165 −1,402
Highlightsmeasured by the reviewers, before → after
Pack >2 GiB: object lookups past offset 2^31 are O(row); full linux clone checkout stalls, cat 250x slower
20k-row last-offset lookup median3042× better████████████████████████ 15,212 ns per lookup █ 5 ns per lookup
Blobless clone: diff lazy-fetch batching collapses above ~1000 missing blobs (+318 packs, 4.6 s vs git 0.65 s)
600-pair regression promisor fetch calls1200× better████████████████████████ 1,200 calls █ 1 calls
backend::check_transaction clones every ref per call: each MemoryRefStore/custom-store write is O(all refs)
check_transaction with 20,000 stored refs and one-ref creates1031× better████████████████████████ 1,104 µs/check █ 1.1 µs/check
upload-pack buffers a large packed blob in memory: 1.5 GB blob clone peaks at 2.8 GB anonymous RSS (git: <1 MB)
48 MiB regression fixture packed size1028× better█ 48,967 bytes ████████████████████████ 50,347,046 bytes
reftable writer never compacts: 1000 ref updates take 37 s and leave 1002 tables (git: 2.5 s, 3 tables)
Table files after 1,000 CAS updates1001× better████████████████████████ 1,001 files █ 1 files
issues fixed100
  • ›grit commit: failing pre-commit/commit-msg hook leaves the auto-staged index (staged/unstaged split lost)#2253132060ba

    Auto-staged commits now hold the repository index lock before staging and give hooks a temporary index containing the staged view. The real index is persisted only after the ref update, so failed pre-commit or commit-msg hooks no longer destroy a curated staged/unstaged split or stage untracked files.

  • ›grit --stat/--numstat and log -G align lines differently from grit's own patch (stat says 32 deletions, patch 1)#2236e6e6f6c2

    Tree and commit-pair stats now count the compacted line operations already used by structured patches, instead of taking a separate LF-only shortcut. This removes phantom or missing lines in stat/numstat/shortstat while retaining the existing shared patch and pickaxe alignment.

    Cargo 403f1e12f release numstat median (20 runs; system Git 2.143 ms): 4.1 ms → 3.5 ms (18% better)log_stat 100k lines / small edit midpoint: 2.8 ms → 5.6 ms (51% worse)
  • ›rebase of a branch with a merge commit: spurious 2nd conflict, merge loses 2nd parent and merged-in files#224566509e80

    Rebase now distinguishes the branch's first-parent line from commits that enter through a merge. Side branches retain their own ancestry, and resolving a stopped merge replay keeps all merge parents, preventing merged files and topology from being silently lost.

  • ›diff/show --patch-text of a modified binary emits 'literal 0' binary patch (git apply fails); worktree diff has no body#22445a2ba929

    Binary patch-text emission now retains the inflated blob or worktree bytes needed to encode real `GIT binary patch` literal sections. Ordinary line/status diff paths still discard binary payloads and retain the existing big-file memory optimization.

    Patch generation median (origin/main → review, 20 runs): 2.7 ms → 7.0 ms (61% worse)Patch generation median (system git → review grit, 20 runs): 5.1 ms → 7.0 ms (27% worse)
  • ›clone --single-branch -b <branch> fetches all tags and their history: cargo 77 MB / 23.7k commits vs git 38 MB / 13.2k#22522239c9db

    Single-branch clones now follow only tags reachable from the selected branch instead of requesting every advertised tag and its history. Bare clones also stop creating synthetic `refs/remotes/<name>/*` refs, matching Git’s ref layout.

    Cargo single-branch tag count: 124 tags → 23 tags (5.4× better)Cargo reachable commit count: 23,722 commits → 13,197 commits (80% better)Cargo clone disk size: 77,740 KB → 37,468 KB (2.1× better)Cargo clone wall time: 4.7 seconds → 2.0 seconds (2.3× better)
  • ›grit rebase stopped on conflict, finished with `git rebase --continue`: branch ends on the tip of a stacked branch#2255ca4d4686

    When grit exposes a stopped rebase to Git, the Git-visible todo now contains only commits belonging to the branch actually being rebased. Grit retains its complete internal replay plan, so resuming with grit still updates stacked branches while resuming with Git finishes only the primary branch.

  • ›grit rebase --exec <upstream> is a silent no-op when the branch is already on top of upstream (git runs the command)#22466f4b012d

    Already-based rebases with `--exec` now run commands over the selected commit range without changing commit IDs when commands are no-ops. If a command amends history, the checked-out branch and scoped stacked branches are remapped together; human, Markdown, and JSON output report executed commands instead of claiming nothing happened.

  • ›grit fsck reports failure (exit 1) on every fresh reftable repository: badRefContent refs/heads, badReferentName HEAD#2248f4258f2c

    Reftable repositories no longer fail integrity checks solely because of the Git-compatible HEAD and refs/heads sentinel files. Fsck now validates the actual shared and worktree-local reftable stacks, and the round-3 commit brings the public API snapshot in sync with the added store traversal method.

  • ›Threads updating different branches through one Repository fail with LockHeld: files RefStore has one writer slot#22504e725e99

    Files-backed ref transactions now own their lock and snapshot state per prepared transaction, so independent branches update concurrently instead of contending on one repository-wide writer slot. Commit-time directory/file ref-name races remain safe and typed, and round three restores unrelated MSRV and Unix interruption coverage that regeneration had accidentally displaced.

    8-thread disjoint update elapsed time over 40,000 updates: 3,739 ms → 1,675 ms (2.2× better)8-thread disjoint update throughput: 10,698 updates/s → 23,881 updates/s (2.2× better)
  • ›grit receive-pack / grit-http-server write received packs as mode 0600 (git: 0444), breaking shared repos#225172939921

    Newly installed kept packs and their index/reverse-index sidecars are finalized read-only while honoring the process umask and core.sharedRepository. Receive-pack now writes Git-compatible readable modes for shared repositories and emits a valid .rev by default; the round-two follow-up also restores two unrelated regression-test gates that had been weakened.

  • ›grit merge of wide branches (5k-30k changed files) in a 300k-file repo is 4-10x slower than git; Index::remove per path#2254acaa4ccd

    Wide merges now apply sparse merge results to the index in one sorted compaction/merge pass instead of shifting a large entry vector once per touched path. Matching stage-0 rows survive harmless in-memory fsmonitor flag differences, and remaining stat rows are overwritten in place.

    300k files, 5k/300 conflict merge wall time: 9.0 seconds → 3.0 seconds (3.0× better)300k files, 5k/300 conflict merge peak RSS: 257,056 KiB → 254,524 KiB (1% better)300k files, clean 5k/0 after git status wall time: 10.8 seconds → 2.1 seconds (5.2× better)
  • ›macOS ignorecase: grit commit auto-stage renames tracked dirs/files to the on-disk case, rewriting unrelated paths#2247430e5a24

    Prevents add and commit auto-staging from silently changing indexed path case on case-folding filesystems. It preserves indexed directory/leaf spellings for aliases and makes filesystem case detection collision-safe, while retaining tracked-path respelling on case-sensitive filesystems.

  • ›grit merge silently auto-merges a CRLF-converted file with an edit (mixed line endings); git reports a content conflict#2259aaccba1b

    Merge comparison now preserves CRLF-vs-LF differences by default, including a lone CR on an incomplete final line. It still supports explicit ignore_cr_at_eol behavior and produces Git-compatible conflict blobs/stages for the reported histories.

  • ›RefStore transactions accept symbolic HEAD -> 'foo' (or loop/invalid names): repo then unreadable by git#22582102b29a

    Ref transactions now reject malformed symbolic-ref targets before locking or writing, with a typed error. Repository-backed stores also validate every nonzero object ID that a reflog-only update will record—including the previously missed `log_only + new_value: None` representation—while preserving object-blind raw backends and explicit verification opt-outs.

  • ›history absorb finds nothing (all hunks no_candidate) when another local branch sits at HEAD, with no explanation#2256162100c8

    Absorb no longer treats a second local branch name at HEAD as a history boundary. When another local tip genuinely excludes an introducing commit, plans and CLI output identify that ref, while commits excluded independently by the ten-commit cap or fork-point remain ordinary no_candidate results.

  • ›grit reset (non-dry-run) warns 'would become unreachable' in future tense, ignoring that reflog keeps the commits#226689cca995

    Makes reset output accurately distinguish a preview from a reset that has already moved the branch. Successful resets identify the previous tip and give a concrete recovery command, while Markdown gains the same recovery guidance and JSON remains stable.

  • ›grit push --delete reports "pushed <branch> → origin refs/heads/<branch>" instead of a deletion#22673cae0dc8

    Successful remote ref deletions now render as deletion actions instead of ordinary pushes. JSON gains an optional per-result `deleted: true`, while normal pushes and existing rejection/exit behavior remain unchanged.

  • ›blame_file returns line content as lossy String: non-UTF-8 bytes become U+FFFD with no flag or raw bytes#22600ffd2cb8

    Blame now preserves exact bytes for individual non-UTF-8 lines while retaining the existing lossy display string. Structured CLI output marks only affected lines, including a parallel per-line flag array for grouped JSON.

    Median release `grit blame` on identical branch repository: 0.130 seconds → 0.126 seconds (3% better)Median release branch grit versus system git on identical repository: 0.104 seconds (system git baseline → branch grit) → 0.126 seconds (system git baseline → branch grit) (17% worse)
  • ›grit commit after a pick conflict loses the picked author and leaves CHERRY_PICK_HEAD; --continue/--abort fail#2262739acbeb

    A normal `grit commit` can now correctly finish a conflicted pick or revert instead of leaving stale operation state. Pick completion preserves the picked commit's author identity and date, while replay continue/abort/skip understand a step that was committed through the normal commit command.

  • ›Windows: grit creates loose refs named aux/con/com1 that system git cannot read (git log --all fatal, fsck errors)#2257e21fa761

    This change prevents the Windows files ref backend from creating loose refs or reflogs under Win32-reserved path components, while leaving Unix and reftable behavior intact. Initial imports that are guaranteed to write only packed-refs remain accepted, including reserved names such as `aux`.

  • ›Windows: concurrent create_commit in one process fails with 'insufficient permission ... Access is denied' (not retried)#2261684b0432

    Adds an atomic git-dir file replacement path that retries transient Windows sharing failures and closes index lock handles before publication. It preserves fatal ACL errors, reports exhausted index/ref contention as retryable file-in-use errors, normalizes ref lock paths, and documents the CLI guidance.

  • ›Pack >2 GiB: object lookups past offset 2^31 are O(row); full linux clone checkout stalls, cat 250x slower#2265d2b2221d

    Large-pack object lookups now use the slot encoded in each v2 index row to read the corresponding 64-bit offset directly. This removes a scan from row zero on every lookup while preserving corruption checks at the appropriate lazy- and strict-open boundaries.

    20k-row last-offset lookup median: 15,212 ns per lookup → 5 ns per lookup (3042× better)
  • ›grit cat <tree> opens every entry's object twice: 200k-entry dir 1.9 s warm / 8.2 s cold vs git ls-tree 0.09 s / 0.13 s#22692f71eedb

    Tree listings now derive each entry's displayed type solely from its mode, without opening the referenced object. `grit cat` parses a tree once and builds only the representation needed for the selected output mode; `grit show REV:path` reuses its first parse and preformatted human bytes.

    50k-entry human cat median wall: 189.4 ms → 13.8 ms (14× better)50k-entry human cat median peak RSS: 33.8 MiB → 22.5 MiB (51% better)50k-entry JSON cat median wall: 209.4 ms → 35.0 ms (6.0× better)50k-entry JSON cat median peak RSS: 33.9 MiB → 30.5 MiB (11% better)
  • ›grit rebase replay costs ~90 ms per commit on cargo: 60 commits onto +1059 upstream 5.7 s (git 1.0 s)#226322c4ce79

    This adds a per-plan replay merge session that analyzes the fork-to-onto delta once, then splices simple disjoint commit changes directly into the new parent tree. Collisions and complex cases retain the existing three-way merge fallback, while partial tree writing now prunes empty subtrees correctly.

    Cargo 60-commit replay median wall time (origin/main to branch): 6.3 seconds → 0.376 seconds (17× better)Cargo 60-commit replay median peak RSS (origin/main to branch): 61,848 KiB → 58,936 KiB (5% better)Cargo 1-commit replay median wall time (origin/main to branch): 0.350 seconds → 0.345 seconds (1% better)Cargo 60-commit wall time (system Git to branch grit): 1.0 seconds → 0.376 seconds (2.7× better)
  • ›v0.5.24 linux: grit log --oneline over 24k-commit history 1.8x slower than git (211 ms vs 118 ms)#22641e65b2ed

    This change makes bulk object-id abbreviation use mmap-backed pack-index neighbor checks and cached loose-object state, then uses that batch API to render plain human/Markdown `log --oneline` directly from revwalk-retained commit bytes. The round-3 fix preserves uniqueness when a collision lives in an alternate object store by forcing bounded full-ODB disambiguation whenever secondary read layers are configured.

    24k packed full-history grit median (9 warm runs): 218.2 ms → 185.3 ms (18% better)24k packed path-limited d3 grit median (7 warm runs): 158.8 ms → 153.8 ms (3% better)24k full-history grit/system-Git ratio: 2.5 x → 2.1 x (18% better)
  • ›merge/predict_merge use only the first merge base on criss-cross histories: clean merge where git reports conflicts#2114f9813499

    Merges with multiple equally good ancestors now first combine those ancestors into a virtual merge base. Prediction, merge-tree writing, and real branch integration share the same implementation, including Git-compatible nested conflict blobs and outer-only ours/theirs favoring.

    Single-base 3000-commit fork median: 18.1 ms → 18.2 ms (1% worse)Criss-cross 3000-commit fork median: 18.0 ms → 18.5 ms (3% worse)
  • ›grit-lib fails to compile on macOS: finalize_pack_file_mode passes u16 mode to Permissions::from_mode#2270accb7a5f

    Makes pack sidecar permission finalization compile across Unix platforms whose mode_t widths differ. It also fixes the existing permission regression test so its 022 and 077 expectations are exercised under the intended process umask.

  • ›grit reset --hard peaks at 2.5-2.9x git's RSS on large trees even with nothing to change (300k files: 238 MB vs 95 MB)#22684854ec36

    Hard reset now reconciles the loaded index with the target tree in place, probes worktree state by index position, and rebuilds valid target cache-tree metadata instead of retaining several full-tree/index copies. The round-five addition specifically restores the target cache-tree after different-commit resets using lockstep subtree reuse with a tree-derived fallback.

    300k-file no-op hard-reset peak RSS (origin/main vs branch, second warm run): 236,828 KiB → 115,820 KiB (2.0× better)300k-file no-op hard-reset wall time (origin/main vs branch, second warm run): 0.712 seconds → 0.535 seconds (33% better)30k-file branch peak RSS max across 20 runs vs system Git: 27,088 KiB (branch vs Git reference) → 13,972 KiB (branch vs Git reference) (94% better)
  • ›macOS: auto-stage commit rewrites Docs/guide.md from colliding docs/guide.md (directory-case collision not protected)#2272fc769fee

    This protects both index entries when two directory spellings collapse onto one worktree directory on a case-folding filesystem. Status and auto-stage now recognize that the shared file already contains a sibling entry’s blob, but a genuinely new edit still updates the actual dentry spelling.

  • ›Concurrent commits to different branches fail ~55% with LockHeld on an injected MemoryRefStore (global lock, no retry)#21811a064733

    Repository-backed injected ref stores now honor core.filesRefLockTimeout when retrying a busy writer slot. This fixes high-contention MemoryRefStore and database-style backends without changing raw prepare semantics or uncontended writes.

  • ›Windows: grit creates loose refs named aux/con/com1 that system git cannot read (git log --all fatal, fsck errors)#2257bc943134

    Activates the already-implemented Win32 loose-ref path guard in the files ref store. Ordinary transactions now reject reserved path components before creating ref locks or loose files, while the initial packed-only optimization remains allowed because it creates no Win32-inaccessible path.

  • ›grit history undo refuses after a rebase that stopped on conflicts and finished with --continue#227499d0f51e

    When a stopped rebase completes through continue or skip, Grit now rewrites `history-last` after HEAD is reattached. The record names the original branch and its true pre-/post-rebase tips, allowing history undo and redo to work like an uninterrupted rebase.

  • ›Blobless clone: grit diff A B lazy-fetches one blob at a time (552 packs, 5.7 s vs git 0.36 s, 1 pack)#2275157a819d

    Content-producing tree diffs now gather their distinct old/new blob IDs and prefetch all missing promised blobs before parallel workers read content. Name-only diffs still avoid blob fetches, and the existing per-object lazy-fetch path remains available for unbatched callers.

    Blobless 600-file diff elapsed (origin/main → review branch): 2.9 seconds → 0.056 seconds (52× better)New packs from blobless 600-file diff (origin/main → review branch): 600 packs → 1 packs (600× better)Blobless 600-file diff elapsed (system Git comparator → reviewed grit): 0.038 seconds → 0.056 seconds (32% worse)Fully local 600-file diff median (origin/main → review branch, 10 runs): 0.010 seconds → 0.009 seconds (0% better)
  • ›status/diff stat a 200k-file single directory serially: 2.9-3.1x slower than git (preloadIndex); --threads has no effect#2276b5c045ac

    This change divides directory-sorted tracked entries into balanced worker slices, allowing one very large directory to use multiple stat workers. It keeps slices ordered, checks symlink ancestors before each slice, and leaves Windows on one worker per directory to avoid duplicate listings.

    flat 200k status, current main vs branch, --threads 4 best of 8: 354.5 ms → 244.5 ms (45% better)flat 200k diff, current main vs branch, --threads 4 best of 8: 158.3 ms → 63.7 ms (2.5× better)flat 200k diff --exit-code, current main vs branch, --threads 4 best of 8: 177.4 ms → 70.8 ms (2.5× better)flat 200k add ., current main vs branch, --threads 4 best of 8: 412.8 ms → 263.6 ms (57% better)
  • ›integrate_branch: short branch name as into_ref fails with misleading ExpectedMismatch; form of into_ref undocumented#22773a4ffb25

    Short local branch names passed to the merge porcelain API are canonicalized to `refs/heads/...` before any merge state or ref update. Missing short branches now return `BranchNotFound` without writing `ORIG_HEAD`, while full refs retain the existing compare-and-swap behavior; docs and system-Git-backed regression coverage describe both forms and merge-message behavior.

  • ›backend::check_transaction clones every ref per call: each MemoryRefStore/custom-store write is O(all refs)#228208f13c4e

    Ref transaction preparation no longer copies every stored ref and reflog. It probes the ordered ref map for D/F conflicts, simulates ordered writes in a small overlay, and commits MemoryRefStore transactions in place with touched-state rollback.

    check_transaction with 20,000 stored refs and one-ref creates: 1,104 µs/check → 1.1 µs/check (1031× better)
  • ›receive-pack unpack path holds the whole blob in memory: 600 MB push peaks at 600 MB RSS (git: 4.5 MB)#228405c07517

    Strict receive-pack verification no longer reloads ordinary blob payloads after the unpack path has already streamed and stored them. It still parses all object kinds that can contain references and preserves the separate `.gitmodules`/`.gitattributes` validation path.

    600,000,000-byte receive-pack peak RSS (debug grit; system git control 11,724 KB): 627,036 KB → 45,032 KB (14× better)600,000,000-byte receive-pack elapsed time (debug grit; system git control 13.461 s): 78.5 seconds → 64.8 seconds (21% better)96 MiB receive-pack peak RSS (debug grit): 139,248 KB → 44,796 KB (3.1× better)
  • ›reftable writer never compacts: 1000 ref updates take 37 s and leave 1002 tables (git: 2.5 s, 3 tables)#22798d7d2d36

    Ref-store transactions now invoke geometric reftable compaction after publishing a successful table update, keeping repeated updates bounded instead of accumulating one table per transaction. The round-2 fix explicitly carries the repository Environment into write-option discovery, preserving the hygiene contract without hidden process reads.

    1,000 CAS update elapsed time: 3,602 ms → 542.7 ms (6.6× better)Table files after 1,000 CAS updates: 1,001 files → 1 files (1001× better)
  • ›RefTransaction::push_update/update is O(n) per call: building a 100k-ref batch takes 21 s (prepare+commit: 60 ms)#22819a6eddb0

    RefTransaction now maintains a private set of queued ref names, so adding each update no longer scans every prior update. Immediate duplicate rejection and all existing transaction behavior remain unchanged, with focused tests covering constructor synchronization and scaling.

    100k push_update construction: 21,838 ms → 27.3 ms (799× better)8k / 2k construction-time ratio: 14.3 ratio → 3.4 ratio (4.3× better)8k push_update construction: 67.0 ms → 2.5 ms (27× better)2k push_update construction: 4.7 ms → 0.739 ms (6.3× better)
  • ›grit diff A B on git/git: content diff of translation files 10-14x slower than git (1.25 s vs 92 ms), 2-3x RSS#2273c762ed93

    Optimizes Myers line diffing for large repetitive text by materializing contiguous interned record IDs and reusing per-thread scratch buffers. It also gives no-index shortstat a hunk-free line-count path while preserving the existing three-argument public diff_paths API.

    no-index ca.po shortstat median: 28.6 ms → 24.9 ms (15% better)repository whole-range shortstat median: 106.6 ms → 101.6 ms (5% better)repository ca.po shortstat median: 15.8 ms → 16.1 ms (2% worse)whole-range peak RSS median: 50,376 KiB → 53,664 KiB (6% worse)
  • ›upload-pack v0/v1 never sends 'ACK ready': 20-commit fetch needs 931 haves/30 rounds, 0.70 s vs git 0.09 s#228378fb27c3

    This change teaches protocol-v0/v1 upload-pack negotiation to tell multi_ack_detailed clients when their acknowledged history fully covers the requested commits. It also corrects the round-state edge case from review round 1, ensuring any absent have suppresses a later flush-time ready response while preserving the immediate absent-oid ready response when coverage was already established.

    Median protocol-v0 fetch time on local 11,952-commit packed repo (system Git: 253.47 ms): 598 ms → 540.8 ms (11% better)Client have lines on the realistic protocol-v0 fetch: 71 haves → 32 haves (2.2× better)
  • ›refs::write_symbolic_ref/read_head/list_refs(git_dir) use disk and split-brain with an injected RefStore#2285045c658e

    Repository-aware ref operations now consistently use the Repository’s selected RefStore, so an injected backend cannot silently diverge from stray HEAD or refs files. Bare git-dir helpers remain supported and are explicitly documented as opening a fresh on-disk backend.

  • ›Remote::fetch from a local/file:// remote reports no progress for 70% of the run, then one set() for the whole copy#227865f01903

    Local and file-backed fetches now expose enumeration, copying, indexing, and delta-resolution progress instead of staying silent through most of the operation. The round-2 correction makes whole-store local clone totals and updates count Git objects, not pack sidecar files or wanted refs.

    Packed local bare-clone median, 155,057 objects / 20 warm runs: 10.3 ms → 10.4 ms (1% worse)Packed local bare-clone time relative to system git: 1.5 x git → 1.5 x git (1% worse)
  • ›grit rebase: commits editing paths touched by upstream renames: 60 commits 10.7 s (git 1.2 s)#22718f7bb9c2

    Caches the fork-to-onto diff, file renames, directory rename roots, and similarity scores once per replay session. Overlapping commits then reuse that analysis in a sparse three-way transplant, while conflicts are returned directly and unsupported cases retain the full-merge fallback.

    Release rebase, 500 inexact renames + 20 identity-overlap commits: origin/main to branch: 2.0 seconds → 0.236 seconds (8.5× better)Same release fixture: system git to branch: 0.074 seconds → 0.236 seconds (69% worse)Committed release planning fixture: reported author run to reviewer run: 0.075 seconds → 0.096 seconds (22% worse)
  • ›upload-pack buffers a large packed blob in memory: 1.5 GB blob clone peaks at 2.8 GB anonymous RSS (git: <1 MB)#228779f18505

    Upload-pack now writes the PACK header, entries, and trailer directly to the caller instead of retaining a complete pack or large object in anonymous memory. Packed whole objects are copied from mmap-backed ranges in 64 KiB chunks, while large loose objects are inflated and re-deflated through bounded streams.

  • ›grit-lib serve API: ReceiveHook cannot see push options; upload_pack/receive_pack have no cancel token or transfer stats#22897bae7a38

    Extends the in-process serve API so receive hooks can inspect push options before refs move, uploads return typed transfer statistics, and upload/receive operations can be cancelled. The round-two fix preserves upload statistics across normal stateful protocol-v2 command sequences instead of discarding them at EOF.

  • ›upload-pack sparse:oid filter omits blobs git sends (nested dirs under a matched dir); 64 s on cargo vs git 13 s#221289128f9c

    This change makes sparse:oid enumeration cache sparse path decisions and fully enumerated subtrees without skipping unchanged parent subtrees across commit history. It also supplies pack name hashes and adds system-Git compatibility regressions for nested, aliased, and deep-history tree shapes.

    Cargo sparse clone wall time (origin/main to reviewed branch): 60.8 seconds → 5.8 seconds (10× better)
  • ›Remote::fetch/push/clone cannot target a custom ObjectStore primary; no wire API that hands the pack to a sink#2288bf750b92

    Fetch and push can now use a custom writable object-store primary instead of requiring the files backend. Clone can populate an already-open repository while preserving injected object and ref stores, including correct default-branch creation and worktree checkout.

  • ›switch / reset --hard / merge / stash pop rewriting 22.5k files peak at 2.6-4.7x git's RSS (90-108 MB vs 22-26 MB)#228071dda1c2

    Bounds wide-tree checkout memory by processing write jobs and outcomes in chunks, reducing per-file checkout metadata, and releasing hard-reset planning data before applying changes. It also corrects bulk checkout attribute handling per path and adds reliable Git-compatibility and peak-RSS regressions tied to the exact release binary under test.

    Wide-tree reset peak RSS: system Git baseline → reviewed Grit: 19,740 KiB → 33,260 KiB (41% worse)Wide-tree RSS ratio to system Git: 1 × → 1.7 × (41% worse)
  • ›porcelain::status rewrites .git/index on stat refresh; no read-only mode (GIT_OPTIONAL_LOCKS ignored)#229021cbfa07

    Status can now be explicitly read-only and honors captured GIT_OPTIONAL_LOCKS, avoiding opportunistic index writes and rewrite recovery when optional locks are disabled. The CLI exposes the same behavior globally, compatibility tests cover index/journal preservation, and the round-2 repair keeps unrelated hard-reset coverage in the default gate.

  • ›reflog expire/delete rewrite the reflog without the ref lock: concurrent ref updates lose entries or fail#22865aac5c3a

    Reflog read-modify-write operations are serialized by each built-in ref backend, preventing concurrent ref updates from being overwritten. Delete, expire, and stash-drop paths now perform their decisions against locked current state or use snapshot validation and retry.

  • ›upload-pack buffers a large packed blob in memory: 1.5 GB blob clone peaks at 2.8 GB anonymous RSS (git: <1 MB)#2287467d7b0b

    Large full objects can now be copied from v1-index packs without first inflating the entire payload into anonymous memory. The same bounded CRC path is reused for v2 bitmap selection, large body writes are chunked, and the regression fixtures now use genuinely incompressible data.

    48 MiB regression fixture packed size: 48,967 bytes → 50,347,046 bytes (1028× better)
  • ›Git-habit `-n` on clean/add/rm/mv gets clap's "to pass '-n' as a value, use '-- -n'" tip instead of `--dry-run`#22975d6c8c17

    Grit now recognizes a common Git habit when users pass `-n` to add, rm, mv, clean, or push and points them to the supported long-form `--dry-run`. The existing misleading Clap suggestion to treat `-n` as a path is suppressed, including for clean's `-fn` and `-nf` clusters.

  • ›Repository::init with InitOptions::with_environment returns a hermetic handle: first commit fails MissingConfiguredEmail#2294feb91e79

    An environment supplied while initializing a repository now remains attached to the returned handle across normal, bare, separate-git-dir, and bare-with-worktree layouts. Commit creation also validates author/committer identity before storing the tree, preventing failed first commits from leaving dangling trees.

  • ›grit log --since combined with --author/--grep/pathspec walks all history: 1.3 s vs git 80-96 ms on git/git#2230929f50ca

    Filtered and path-limited log walks now honor a committer-date `--since` frontier even when callers omit an explicit `-n`. This fixes the default-page case that previously traversed all history when fewer matches existed than a page could fill.

    git/git --since=2025-01-01 --author=Junio median (system git: 74.43 ms): 1,249 ms → 71.3 ms (18× better)git/git --since=2025-06-01 --grep=fix median (system git: 53.19 ms): 1,219 ms → 58.3 ms (21× better)git/git --since=2025-01-01 -- builtin/log.c median (system git: 37.36 ms): 496.2 ms → 30.9 ms (16× better)git/git --since=2026-10-01 -- Makefile median (system git: 4.72 ms): 623.0 ms → 5.6 ms (111× better)
  • ›grit rename similarity differs from git (94% vs 95%): wrong diff --json similarity and patch-id mismatch#22913b418e2e

    This changes rename and copy similarity from whole-line hashes to the 64-byte/newline span hashes used by Git 2.43. It preserves raw blob sizes in the denominator, handles CRLF the same way as Git, and routes the corrected score through JSON diff and stable patch-id generation.

    Cargo config_value rename similarity: 94 percent (Git 2.43 = 95) → 95 percent (Git 2.43 = 95) (1% better)
  • ›Mid-rebase, pull/merge say 'HEAD is detached' and pick says 'commit them with grit commit' (which wedges the rebase)#2295101cfba2

    Paused rebase state is now detected before commands interpret its detached HEAD or conflict markers as unrelated errors. Pull, merge, rebase, pick, revert, and branch rename render a consistent refusal with actionable continue/abort commands, while foreign Git-owned rebases retain Git-specific ownership messaging.

  • ›reset --hard warning tells the user to recover with `grit reset <oid>`, which is mixed and leaves the files deleted#22963b7d852c

    Reset orphan warnings now tell users to recover with the same reset mode that caused the branch move. Following a hard-reset hint restores deleted tracked files, while soft and keep recovery retain their non-destructive mode semantics; mixed remains the unflagged default.

  • ›grit patch-id differs from git patch-id --stable for a plain 6-line insertion into a 437-line file (git/git t4201)#2292126cb2fa

    Patch-ID hashing now decodes invalid UTF-8 with the same borrow-or-lossy rule used by structured diffs, instead of treating an entire blob side as empty. This restores hunk alignment for invalid bytes in distant unchanged text and fixes the reported insertion mismatch across all three patch-ID text-hunk paths.

    Grit patch-id median debug wall time on exact invalid-UTF-8 fixture: 6.1 ms/command → 7.0 ms/command (13% worse)
  • ›grit gc ignores gc.writeCommitGraph=false, gc.packRefs=false and pack.writeBitmaps that git gc honors#23016e889c42

    GC now respects the maintenance settings users carry from Git: commit-graph and ref packing can be disabled, `notbare` behaves correctly, and either bitmap spelling participates in load-order precedence. Ref cleanup also keeps stable namespace directories such as `refs/heads` while still pruning empty descendants.

  • ›Regression of #1218: grit log/revs -- <path> from a subdirectory finds nothing (pathspec resolved against cwd twice)#2298c2b8ad0d

    This change removes duplicate cwd resolution for log/revs pathspecs and completes the pathspec engine behavior needed for excludes and long glob magic from subdirectories. It adds CLI and library Git-oracle regressions for ordinary relative paths, top magic, excludes, globs, and pathspec files.

  • ›grit worktree add <path> <branch> fails in a bare repo when HEAD points at that branch ('already checked out')#2305d377cd4c

    Bare repository HEAD now remains a ref pointer rather than being mistaken for a checkout. This enables the standard bare-repo-plus-linked-worktrees layout while retaining branch exclusivity once a real linked worktree checks out the branch, and list output identifies the bare row clearly.

  • ›grit commit during a rebase conflict, then rebase --continue fails 'nothing to commit after conflict resolution'#22934b77b90a

    A conflict-resolution commit made during a grit-owned rebase stop now counts as the rewritten pick, so `rebase --continue` safely replays the remaining commits instead of reporting nothing to commit. Round 3 closes the legacy-state escape hatch by validating any inferred stop against the saved replay base before applying the first-parent safety check.

  • ›Revision ':/text' picks the first matching ref's commit, not the youngest matching commit across all refs#2300d4c82079

    Global `:/<text>` resolution now searches commits reachable from all refs and HEAD in descending committer-date order, rather than returning the first ref-order match. The round-2 revision removes the many-ref slowdown by sourcing linkage from the commit-graph when available and caching each fallback commit parse/message.

    Successful :/Fix public-API process, origin/main (incorrect semantics) → branch: 2.6 ms median, 15 runs → 23.9 ms median, 15 runs (89% worse)No-match public-API process, origin/main → branch: 101.1 ms median, 15 runs → 113.5 ms median, 15 runs (11% worse)Successful :/Fix, system Git → branch grit CLI: 22.5 ms median, 15 runs → 23.7 ms median, 15 runs (5% worse)No-match, system Git → branch grit CLI: 104.8 ms median, 15 runs → 109.1 ms median, 15 runs (4% worse)
  • ›--json unknown-revision error has no `kind` on 12 commands; documented revision_not_found only from merge#2304981f197d

    This change makes machine-readable revision failures consistent across the affected commands while retaining each command's existing human error text. It also gives branch-create failures their documented start-point kind and names missing filesystem paths in bundle/init errors.

  • ›grit log/revs -- '*/g.c', ':(glob)**/f.c', ':(icase)A/g.c' return no commits (wildcard pathspecs can't match in dirs)#2299981f197d

    Path-limited revision walks now descend through wildcard and case-folded directory components instead of incorrectly pruning matching subtrees. The round-3 correction makes the new case-insensitive prefix test safe for unrelated non-ASCII directory names, preventing the reported panic.

  • ›Windows: grit serve --setup/db fails with 'unable to open database file' when the root path is over 260 chars#23109387225b

    AuthStore now gives SQLite a Windows extended-length path only when an absolute database path exceeds the traditional 259-UTF-16-unit limit. The caller-visible path remains unchanged, and regression coverage verifies drive paths, UNC paths, slash normalization, repeatable setup, persistence, and already-prefixed reopen behavior.

  • ›receive-pack creating many new refs (files backend) is quadratic: 20k branches 202 s vs git 29 s#230983e219a5

    Large non-atomic receive-pack batches now attempt one ref transaction instead of committing every accepted command separately. Plain direct creates are published by one locked packed-refs rewrite; mixed batches use the regular transaction path, and a failed non-atomic batch retries per ref so valid commands can still land.

    4,000-ref in-process receive-pack time: 0.507 seconds → 0.050 seconds (10× better)8,000-ref in-process receive-pack time: 1.2 seconds → 0.100 seconds (12× better)4,000→8,000 receive-pack scaling ratio: 2.3 x → 2.0 x (16% better)4,000-ref grit/system-Git time ratio (system Git 0.190369 s): 2.7 x → 0.264 x (10× better)
  • ›reftable repo: grit serve returns HTTP 500 (ENOENT / 'file is too small') to readers during concurrent pushes#2306bce373b9

    This change makes reftable readers reload the stack when concurrent compaction removes or briefly exposes an unusable table, and changes writers to publish fsynced temporary table files. It adds concurrent reader/writer coverage and Git fsck/ref verification.

  • ›Listing 20k refs in a grit-written reftable stack takes 15 s (git 0.6 s): ls-remote, branch, upload-pack all affected#2308ff8e6bdb

    This replaces repeated full reftable scans and per-ref lookups with indexed range iteration and merged stack traversal. It also safely short-circuits small, name-sorted single-namespace queries while preserving global ordering for multi-namespace callers.

    20k refs: grit branch -n 5 median: 525.2 ms → 2.5 ms (213× better)20k refs: grit branch --json full listing median: 546.0 ms → 29.2 ms (19× better)20k refs: system Git for-each-ref median control: 6.6 ms → 6.6 ms (0% worse)
  • ›receive-pack into a reftable repo costs ~22 ms per ref: 4000-ref push 90 s (git 1.4 s), 20k refs 784 s#2307800be0f8

    Non-atomic receive-pack now batches ref work into at most two store transactions: deletions first, then creates/updates, while preserving per-ref rejection reporting. The round-3 fix ensures allowing-failures preparation still executes rename-only transactions instead of silently treating them as empty.

    501-branch grit receive-pack into reftable: 0.572 seconds → 0.030 seconds (19× better)tables.list entries after 501-branch push: 3 entries → 1 entries (3.0× better)
  • ›grit merge refuses to run on a detached HEAD ('HEAD is detached; grit merge needs a branch'), git merges fine#2314d0ae560b

    Detached checkouts can now perform real, predictive, fast-forward, conflict, continuation, abort, squash, and no-commit merge flows without moving a branch ref. The round-2 correction ensures a completed conflicted merge reports that HEAD moved rather than falsely claiming the current branch moved.

  • ›grit merge of wide branches with 3000 conflicts peaks at 384 MB RSS (git: 118 MB), --check 190 MB#23121ac1f760

    Conflict merges now retain one checkout rollback journal until the single in-memory index has been spliced with conflict stages and safely written. Merge abort also reuses the one-index hard-reset path, reducing peak memory while preserving conflict files, unmerged index stages, cancellation rollback, and Git interoperability.

    Scaled branch merge+abort peak RSS regression cap vs measured: 161,792 KiB → 137,456 KiB (18% better)Scaled branch merge peak RSS regression cap vs measured: 151,552 KiB → 129,720 KiB (17% better)
  • ›grit reset --hard / merge --abort rewriting 30-60k files is 2.8-3.3x slower than git (and 5x slower than grit switch)#231183c279f2

    Hard reset now uses the parallel checkout writer for tree transitions, batches staged index realignment for reset-to-HEAD, and parallelizes the unchanged-path stat scan. Merge abort replaces a full worktree-stat index rebuild with an index/tree diff and the same fast checkout machinery.

    16k-path hard reset wa→wnc median (5 runs): 0.665 seconds → 0.636 seconds (5% better)16k-path hard reset wnc→wa median (5 runs): 0.644 seconds → 0.622 seconds (4% better)8k-staged same-tree reset after merge median (5 runs): 0.495 seconds → 0.394 seconds (26% better)8k-path merge abort median (5 runs): 0.150 seconds → 0.129 seconds (16% better)
  • ›Follow-up: Fix #2306: reftable repo: grit serve returns HTTP 500 (ENOENT / 'file is too small') to readers during concurrent pushes#23064ca53fc9

    Reftable table publication now atomically refuses to overwrite a final `.ref` path created by a concurrent writer. Failed staged writes are cleaned up, and a deterministic race test verifies preservation plus retry behavior.

  • ›porcelain::status ignores Cancel/should_cancel in its stat phase: cancel at 1 s returns after 2.9 s on 1M files#23131d054b51

    Status now observes cancellation during the expensive tracked-file stat and racy-content-check phases instead of waiting for the complete scan. Round 3 keeps ProgressSink polling on the owner thread while removing the crate-private poll type from the public diff options API.

  • ›Ctrl-C/SIGTERM/SIGHUP during grit commit, stash, merge or pick leaves a stale .git/index.lock (git removes it)#23156778d639

    Interrupts during commit, stash, merge, pick, and revert now become cooperative cancellation instead of immediately terminating the process. That lets existing checkout rollback and lock guards restore repository state and delete `index.lock` before the CLI reports `operation cancelled`.

  • ›grit status index refresh overwrites a concurrent commit's index: HEAD advances, index silently reverts (git: never)#23176c7cab25

    Status now remembers the exact on-disk index identity it loaded and checks that identity again only after acquiring index.lock. If a concurrent commit replaced the index, status drops its optional refresh instead of writing stale entries over the commit’s index.

    3,000-file status refresh median: 10.5 ms → 10.5 ms (0% better)
  • ›grit rebase: commits editing paths touched by upstream renames: 60 commits 10.7 s (git 1.2 s)#2271e480f2a3

    Replay bookkeeping now records both the paths changed by a topic commit and the corresponding post-/pre-rename paths from the cached upstream delta. That prevents cache validation from mistaking a replayed edit at the moved destination for external drift and rebuilding rename analysis for every commit.

    Cargo moved-file rebase median wall time (30 commits): 5.7 seconds → 1.2 seconds (4.9× better)Cargo moved-file rebase median peak RSS: 110,376 KiB → 108,088 KiB (2% better)Synthetic 500-rename moved-file median wall time: 0.213 seconds → 0.189 seconds (13% better)
  • ›grit commit --dry-run ignores mode-only (chmod) changes: says 'nothing to commit' but the real commit records them#23184dcea82e

    Dry-run commit previews now notice mode changes even when blob content is unchanged. A chmod-only preview succeeds and reports the path as modified, while mixed mode/content previews list the same files as the real commit.

  • ›Commit/tag object with no blank line or message is 'corrupt' in grit (git accepts): log, revs, clone, gc, push fail#23200dcafd96

    Header-only commit and annotated-tag objects are now readable when EOF terminates the headers without a blank message separator. Grit treats the absent body as an empty message, allowing history walks and object-moving operations to proceed, while writers continue emitting canonical blank-line separators.

  • ›switch/reset --hard over a 100k-file diff is 2.6x slower on main than 0.5.24 (5.7 s vs 2.1 s; git 3 s)#2319c75b8333

    This change prevents a wide checkout from repeating whole-index finalization for every 2,048-path slice. It precomputes worktree rules once, uses existing bounded bulk writers for eligible diffs, and finalizes cache-tree/index state once for general chunked diffs.

    100k-path switch wall time (origin/main → review): 5.9 seconds → 2.0 seconds (2.9× better)100k-path switch user CPU (origin/main → review): 4.7 seconds → 1.1 seconds (4.4× better)100k-path switch peak RSS (origin/main → review): 176,176 KiB → 176,626 KiB (0% worse)100k-path reset --hard wall time (origin/main → review): 6.3 seconds → 5.8 seconds (8% better)
  • ›blame_file(&repo, path) resolves path against the process cwd: repo-relative path fails when cwd is inside a subdir#23258fc9c750

    Library callers can now pass a repository-relative blame path without results changing with the host process cwd. The CLI still behaves like Git from subdirectories by resolving its file operand once before both range parsing and blame, and it displays that same resolved path.

  • ›Legacy tree mode 100664: grit status/diff show phantom change, clone writes non-canonical index mode git rejects#2322756e5f4f

    Canonicalizes historical non-standard regular-file modes whenever trees are compared with an index/worktree or used to populate an index. This removes phantom status/diff changes and prevents checkout and hard reset from writing index modes that system Git rejects.

  • ›Objects::write_tree accepts missing or wrong-kind objects (040000 -> blob) that write_commit and git mktree reject#2323c8ac4e51

    Makes typed tree creation validate every referenced object’s existence and mode-implied kind before writing, while preserving an explicit `allow_missing` escape hatch for partial clones and bottom-up assembly. It also refuses symlinks using Git-reserved metadata spellings, including the NTFS `foo\\.gitmodules` case fixed in round 2.

    tree_write_10k/write_tree_entries midpoint (main merge base 1d054b → reviewed branch): 0.999 ms → 19.8 ms (95% worse)
  • ›grit log --merges/--no-merges/--first-parent -n 20 walks all history: 0.7 s on git/git (git: 2 ms)#23240ebfc181

    Adds a bounded streaming date-order walk for logs constrained by first-parent and/or merge-parent-count filters. It stops after the requested matching page while retaining correct parent counts under first-parent traversal and preserving count results.

    --merges -n 20 mean, debug build, 12,132-commit repo, 20 runs: 658.2 ms → 13.9 ms (47× better)--no-merges -n 20 mean, debug build, 12,132-commit repo, 20 runs: 657.3 ms → 10.0 ms (66× better)--first-parent -n 20 mean, debug build, 12,132-commit repo, 20 runs: 322.2 ms → 10.1 ms (32× better)
  • ›Remote::fetch from a local/file:// remote reports no progress for 70% of the run, then one set() for the whole copy#227816cffd16

    Local fetch now reports source pack-index scanning as enumeration work, without claiming that examined objects have already been copied. Copy progress and received-object counts begin only after hard-linked packs, loose objects, or generated remainder packs are installed.

    5,000-commit packed local fetch median: system Git control vs reviewed Grit debug binary: 63 ms → 83 ms (24% worse)
  • ›plain grit fetch exits 1 on every run after a teammate moves a tag; message says 'did not move', no --force to accept#2326d75c4789

    Default fetch now ignores a remote tag move when that tag name already exists locally, so routine fetches remain successful and leave the local tag untouched. Explicit tag fetches retain rejection safety, and `--force` provides a documented way to accept tag or non-fast-forward updates; pull uses the same option and stops on fetch rejection.

    Plain moved-tag fetch median, origin/main vs review branch: 2.3 ms (200 interleaved dist runs) → 2.2 ms (200 interleaved dist runs) (6% better)Plain moved-tag fetch median, system Git vs reviewed grit: 6.5 ms (200 interleaved dist runs) → 2.2 ms (200 interleaved dist runs) (3.0× better)
  • ›Windows: switch to case-colliding paths warns nothing; grit status is clean but grit diff and git show A.txt modified#2329d302dd94

    Switch now reports case-colliding tracked paths through the public library outcome and all CLI output modes. Checkout smudges misleading collision stat records, while diff/status hashes collision members and commit reports remaining drift instead of falsely declaring a clean tree.

  • ›rebase says 'Already up to date' and replays nothing when HEAD is only --no-ff merges of topics (regression vs 0.5.24)#2321736ede98

    This change makes merge-preserving rebase replay integration branches whose first-parent history consists only of no-ff merges, instead of incorrectly declaring them up to date. It also preserves the documented staged conflict-resolution workflow after side branches are replayed before the mainline.

  • ›Blobless clone: diff lazy-fetch batching collapses above ~1000 missing blobs (+318 packs, 4.6 s vs git 0.65 s)#232773639b49

    Inexact rename detection now gathers unresolved old/new blob IDs and performs one promisor batch fetch before probing sizes or loading content. Two large partial-clone regressions lock in single-request/single-pack behavior beyond the previous cliff.

    600-pair regression promisor fetch calls: 1,200 calls → 1 calls (1200× better)600-pair regression execution time: 96.8 seconds → 1.1 seconds (91× better)600-pair fair fixture wall time (system Git vs branch grit): 181 milliseconds (Git then grit) → 647 milliseconds (Git then grit) (72% worse)
  • ›grit switch deleting many files is quadratic: 150k deletions 69 s (git 2.7 s); linux master->v4.9 180 s+ (git 7 s)#2333de463a12

    This change removes two sources of repeated work during delete-heavy switches. Wholesale safety scans now use precomputed directory prefixes, while checkout builds the prospective index and destination attribute rules once with bulk index updates instead of rebuilding them path-by-path for every chunk.

    20k plain deletions on 30k-file index (warm-cache minimum of 2): 0.826 seconds → 0.312 seconds (2.6× better)20k deletions plus .gitattributes transition on 30k-file index (warm-cache minimum of 2): 1.8 seconds → 0.301 seconds (6.1× better)10k deletions plus .gitattributes transition on 30k-file index (warm-cache minimum of 2): 1.0 seconds → 0.166 seconds (6.2× better)
  • ›grit commit on a split-index repo writes a new 29 MB sharedindex per commit (git writes none), 2.7x slower than git#23346815425f

    Preserves split-index metadata while a commit writes the temporary unified index exposed to hooks. The later primary-index write can therefore reuse the existing shared base for small changes instead of emitting a full new sharedindex on every commit.

    Mean Grit commit wall time over three runs (system Git: 32.2 ms): 94.4 ms → 78.4 ms (20% better)Mean peak RSS over three Grit commits (system Git: 12,492 KiB): 34,340 KiB → 30,327 KiB (13% better)Final sharedindex file count after three commits: 4 files → 1 files (4.0× better)
  • ›grit-lib: no snapshot/restore API for undo logs; stash create fails mid-merge, apply_commit rejects identical untracked#233177e86b87

    Adds a typed grit-lib workspace snapshot API that preserves HEAD, selected refs, raw index stages, worktree contents, and in-progress operation files, then restores them through one repository handle. It also makes stash apply optionally tolerate byte-identical untracked collisions, improves structured error serialization, and adds a required-identity constructor for stash pushes.

  • ›grit reset --hard / merge --abort rewriting 30-60k files is 2.8-3.3x slower than git (and 5x slower than grit switch)#231139a3d5c2

    This replaces merge abort's full hard-reset-style rebuild/stat scan with an index-to-ORIG_HEAD alignment checkout using the parallel checkout writer. It retains trustworthy index stats for unchanged rows, lets rewritten rows receive fresh checkout stats, refreshes only remaining unset rows, and explicitly restores/deletes conflict-only paths.

    60k-file merge-abort median (origin/main → review branch, 18k changed/3k conflicts, 5 runs): 2.4 seconds → 0.621 seconds (3.8× better)60k-file first post-abort git status median (origin/main → review branch, 5 runs): 0.067 seconds → 0.108 seconds (38% worse)
  • ›grit add rewrites blobs already in a pack as loose objects again (#2190 closed): 5k files 10.9 s vs git 0.15 s#23283ef3141c

    This change makes object freshening robust when pack or loose-object files are read-only, while preserving the exact timestamp used on disk for pack-cache signatures. It centralizes the permission-clear/retry/restore behavior and adds scale plus compatibility regression coverage.

    5k packed-blob grit add median: 69.9 ms → 70.6 ms (1% worse)grit/system-git add time ratio on Linux: 2.3 x → 2.4 x (1% worse)
  • ›REGRESSION: grit switch leaves index missing the new tree's files when whole directories are replaced (cargo -> 0.12.0)#233680c6d830

    This change keeps wholesale directory removal for truly deleted trees while excluding any top-level directory reused by the target tree. That prevents newly written files and index rows from being erased during switch/checkout, including across bounded checkout chunks.

    Synthetic repro index entries matching 21-entry target tree: 1 entries → 21 entries (21× better)Synthetic switch median, 12-run debug smoke timing (system git median 2.849 ms): 12.5 ms → 12.7 ms (2% worse)
  • ›grit-lib API hygiene: hidden pub fields, Vec-only walks, 14 Windows warnings, destructive symlink restore#2332bc604459

    This change makes grit-lib cleaner for embedders: internal commit/fetch driver state is no longer exposed, common commit-only revision walks can stream lazily, and platform-specific code builds without the reported Windows warnings. It also makes symlink restoration validate and create links safely without deleting an existing path before an unsupported operation fails.

    grit-lib unit-suite runtime reported by cargo: 38.2 seconds → 36.1 seconds (6% better)
  • ›Cone sparse-index repo: grit status 40x slower than git, diff 700x, and grit status re-expands git's sparse index#2335ff921d13

    Keeps Git-written cone sparse indexes compact across status, diff, and clean add operations, and teaches staged diff to compare sparse-directory placeholders without expanding the whole index. The round-3 correction handles an out-of-cone staged subtree that does not exist in HEAD by reporting its leaf files as additions rather than returning a directory row.

    Clean sparse status median, 30k-file debug fixture: 0.200 seconds → 0.013 seconds (15× better)Status slowdown versus system Git 2.43.0: 43.3 times → 2.9 times (15× better)Clean sparse diff median, 30k-file debug fixture: 0.076 seconds → 0.010 seconds (7.6× better)Diff slowdown versus system Git 2.43.0: 32.9 times → 4.3 times (7.6× better)
  • ›Cancelling a 22.5k-file checkout (integrate_branch) returns after 9-12 s: rollback is ~3x slower than finishing (2.9 s)#2330f1899ce0

    Parallelizes cancellation rollback for wide checkouts, including file removal and restoration, so cancelling no longer serially rewrites every completed path. The follow-up also makes rollback correct for truly delayed process filters by restarting stale filters and completing or retrying delayed smudges before returning.

    22.5k-file late-cancel wall time: 821 ms → 654 ms (26% better)late-cancel / uncancelled ratio: 2.1 x → 1.5 x (41% better)uncancelled fast-forward wall time: 393 ms → 441 ms (11% worse)
other changes31
  • ›Main keeper: make CI on main green (rustdoc)6565b24e

    Qualifies one intra-doc link in the diff API with its crate-level public path. This removes the only broken-link error that made strict workspace rustdoc fail, without changing compiled behavior or API shape.

  • ›Main keeper: make CI on main green (rustdoc)e6e6f6c2

    No branch-specific change exists. The branch records that main already contains the one-line fully-qualified rustdoc link fix at 6565b24e2, and the originally failing documentation build is green.

  • ›Main keeper: make CI on main green (clippy)46eade79

    Removes one private rebase helper that was introduced but never called. This restores the clippy gate without changing runtime behavior or any supported API.

  • ›Main keeper: make CI on main green (clippy)d2b2221d

    This review branch is a no-op against current main. The dead-code helper that broke clippy had already been removed by commit 99dedcac7 before the branch tip, so no additional source change is present or needed.

  • ›Main keeper: make CI on main green (public-api, rustdoc)d79df80c

    Qualifies the replay-abort rustdoc links so strict documentation builds resolve them, and refreshes the committed grit-lib API snapshot with the pinned generator. This is documentation and generated-snapshot maintenance only; runtime behavior is unchanged.

  • ›Main keeper: make CI on main green (rustdoc, public-api)1e65b2ed

    There is no branch-specific change to integrate: the review branch is byte-for-byte the same commit as current origin/main. The original rustdoc-link and public-API snapshot repair had already landed on main before this branch was prepared.

  • ›Quality #55: Move logic into grit-lib3e1f0e05

    This consolidates staged, unstaged, and working-tree diff collection/content loading behind a repository-scoped grit-lib API. grit-cli now filters and renders library results instead of manipulating the index, worktree rules, object sides, and gitlink text itself.

    diff/staged@deep-tree (system git 37.94 ms): 40.6 ms median → 37.0 ms median (10% better)diff/staged@synth-100k (system git 71.00 ms): 46.2 ms median → 43.9 ms median (5% better)diff/stat@synth-100k (system git 104.48 ms): 87.2 ms median → 83.0 ms median (5% better)diff/worktree@big-blobs (system git 316.93 ms): 220.1 ms median → 207.4 ms median (6% better)
  • ›Quality #56: Deduplicated23f90d1

    This replaces roughly twenty hand-written “read object, check commit kind, parse commit” paths with the existing `Odb::read_commit` and `Odb::commit_tree` APIs. Six private commit-tree helpers disappear, CLI loaders become thinner, typed wrong-kind errors become consistent, and focused tests pin the intentionally preserved exceptions.

    switch-10000 median: 19.0 ms → 17.3 ms (9% better)switch-wide-10000 median: 48.7 ms → 50.0 ms (3% worse)pick-10000 median: 55.3 ms → 56.8 ms (3% worse)
  • ›Speed: status/clean@synth-10kb0617c69

    This removes avoidable work from clean status: tracked files are discarded while reading directories, sorted indexes are searched directly instead of copied into a hash set, per-directory ignore files load only when needed, and worktree refresh checks allocate only when hashing is required. The CLI remains unchanged and all behavior stays in grit-lib.

    status/clean@synth-10k grit median (system git 6.64→6.80 ms): 7.8 ms → 7.1 ms (10% better)status/dirty@synth-10k grit median (system git 9.93→10.63 ms): 8.0 ms → 7.4 ms (9% better)status/renamed@synth-10k grit median (system git 6.62→6.64 ms): 8.4 ms → 6.7 ms (25% better)status/clean@synth-100k grit median (system git 58.91→61.78 ms): 52.2 ms → 47.2 ms (11% better)
  • ›Main keeper: make CI on main green (public-api)1bfa138e

    Regenerates the committed grit-lib public API snapshot so the seven `ref_lock_wait` entries appear in cargo-public-api's emitted order. This is a generated-data-only correction; it does not alter the Rust API or runtime behavior.

  • ›Quality #57: Simplify52f1fb94

    Adds one cache-backed ODB API for locating a byte path inside a tree and routes ten private walkers through it. The change removes duplicated tree parsing across diff, history, blame, stash, merge enrichment, and snapshot checkout while retaining each caller's leaf filtering and error mapping.

    diff-10000 grit median (git controls 5.304/5.308 ms): 6.4 ms → 6.4 ms (1% better)stash-push-pop-10000 grit median (git controls 198.115/192.550 ms): 122.0 ms → 121.8 ms (0% better)blame-deep-2000 grit median (git controls 71.558/69.531 ms): 23.2 ms → 23.2 ms (0% better)
  • ›Main keeper: make CI on main green (public-api)9a6eddb0

    This review branch contains no code or snapshot changes. It confirms that main already contains the generated public-API snapshot ordering correction and that the submitted head is green.

  • ›Speed: log/oneline-100@git-gite97f684a

    This removes repeated fixed work from repository opening and log walks: one shared config snapshot, one ODB pack context/reader per page, and reuse of mapped pack indexes. Human and Markdown log rendering also avoids constructing JSON-only commit models, while preserving JSON, decorated, diff, graph, and stat paths.

    log/oneline-100@git-git median (system git 2.942 ms): 3.8 ms → 3.6 ms (6% better)log/oneline-100@git-git peak RSS (system git 14536 KiB): 19,100 KiB → 20,072 KiB (5% worse)log/json-100@git-git median (system git 2.910 ms): 4.0 ms → 4.0 ms (0% worse)log/json-100@git-git peak RSS (system git 14532 KiB): 20,720 KiB → 21,212 KiB (2% worse)
  • ›Speed: add/lines@large-file5ab40094

    This change makes partial line staging operate on a path-restricted unstaged diff, then applies the selected patch without eagerly copying every line or the full index. It also removes unnecessary per-line allocations from structured hunk construction while preserving rendered text and hunk identities.

    add/lines@large-file median wall: 39.7 ms → 19.4 ms (2.0× better)add/lines@large-file peak RSS: 32,739,328 bytes → 26,484,736 bytes (24% better)add/lines@large-file ratio vs system Git: 3.0 x → 1.5 x (2.0× better)add/hunks@large-file median wall: 21.9 ms → 17.5 ms (25% better)
  • ›Main keeper: make CI on main green (fmt)d5e88753

    This applies rustfmt's canonical layout to the `parent_trees_slice` filter condition in rev-list traversal. It is a formatting-only change with no altered expression, API, output, object format, or wire behavior.

  • ›Quality #58: Library API quality07d52329

    History absorb, fixup, squash, drop, and subject now share commit-reading helpers and preserve underlying repository errors instead of flattening them into planning strings. Change-id generation failures receive their own typed HistoryError variant, with public API snapshot and regression tests updated.

    history-reword-1000 grit median (branch-run Git: 6477.9 ms): 129.1 ms → 128.2 ms (1% better)history-reword-1000-rebase grit median (branch-run Git: 6404.4 ms): 130.6 ms → 134.9 ms (3% worse)history-reword-update-refs-head grit median (branch-run Git: 6464.6 ms): 130.8 ms → 127.8 ms (2% better)
  • ›Quality #59: Move logic into grit-lib9c3135e7

    Stash stat generation now belongs to the library: RepositoryStash::diff_stat computes line statistics directly without constructing structured hunks and hunk IDs. The CLI only maps options and renders the returned DiffStat; stash diff entries also gain deterministic path ordering.

    stash show human median, origin/main to branch (5k files, 2k tracked edits, n=20): 15.3 ms → 14.0 ms (9% better)stash show JSON median, origin/main to branch (n=20): 14.9 ms → 13.5 ms (11% better)stash show -u median, origin/main to branch (plus 500 untracked, n=20): 22.2 ms → 20.8 ms (7% better)stash show human median peak RSS, origin/main to branch (n=10): 16.5 MiB → 12.9 MiB (28% better)
  • ›Main keeper: make CI on main green (test)487ff5c5

    Enables nextest setup scripts and moves the checkout RSS setup hook into nextest's supported profile script tables. This makes the CI test command parse its repository configuration again instead of exiting before any tests run.

  • ›Speed: fetch/deepen@git-gite84d7c9d

    Shallow and deepen fetches over protocol v2 now advertise the objects the client already has, including the tip being deepened, so the server sends only missing history. Upload-pack also falls back to a graft-aware object walk when either side is shallow, avoiding bitmap closures that incorrectly cross the client's shallow boundary.

    fetch/deepen grit time (git 676.0→684.2 ms): 5,599 ms → 121.0 ms (46× better)fetch/deepen grit peak RSS: 180.1 MiB → 50.9 MiB (3.5× better)fetch/dry-run grit time (git 114.2→116.9 ms): 47.6 ms → 48.0 ms (1% worse)fetch/incremental-http grit time (git 130.0→128.8 ms): 50.6 ms → 48.6 ms (4% better)
  • ›Main keeper: make CI on main green (public-api, test)34492b48

    Refreshes the committed grit-lib public API manifest so its ordering matches the output of the repository’s pinned cargo-public-api tool. The diff only repositions existing declarations; it neither adds nor removes an API.

  • ›Quality #60: Dead code and dependencies440f8dbf

    Removes an unused diff dependency and a set of public/library helpers that had no production callers, mostly remnants of the removed compatibility CLI and unsupported octopus/legacy diff behavior. It also clears test-build dead-code warnings and restores a status test that had accidentally stopped running.

    Public API snapshot lines: 30,813 lines → 30,721 lines (0% better)Cargo.lock packages: 363 packages → 362 packages (0% better)
  • ›Main keeper: make CI on main green (public-api)440f8dbf

    Refreshes the committed grit-lib API inventory so it matches the deterministic output of the repository's pinned nightly and cargo-public-api version. The only differences reorder existing enum entries and ref-store methods; no API item, behavior, test, format, or protocol changes.

  • ›Speed: branch/list@many-refs0144f496

    This changes CLI startup so clap copies root output/thread flags only into the top-level subcommand actually named by argv, instead of cloning them into all 55 commands. Unknown commands, bare invocation, help, and version retain the stock clap tree; tests compare every command and alias against stock parsing and error rendering.

    branch/list@many-refs wall (system Git 1.105 ms): 1.9 ms median, 400 rotating-order runs → 1.7 ms median, 400 rotating-order runs (9% better)branch/list@many-refs peak RSS (system Git 6597 KiB): 13,244 KiB, mean of two 20-run report medians → 11,490 KiB, mean of two 20-run report medians (15% better)branch/list-json@many-refs wall (system Git 1.561 ms): 2.5 ms, mean of two 20-run medians → 2.3 ms, mean of two 20-run medians (6% better)branch/merged@many-refs wall (system Git 1.583 ms): 2.6 ms, mean of two 20-run medians → 2.3 ms, mean of two 20-run medians (10% better)
  • ›Main keeper: make CI on main green (rustdoc)5466297d

    Corrects the public rustdoc link for revision walking and removes a link to a private diff helper. The exact CI rustdoc command now completes successfully.

  • ›Speed: branch/list-json@many-refs272bf9c6

    This change removes avoidable allocations and character decoding from config parsing, then makes repeated Repository::config() validation re-stat the already-known cascade instead of rebuilding environment-derived state. It adds focused Criterion coverage, exhaustive scanner-equivalence and session-invalidation tests, plus recorded benchmark evidence.

    branch/list-json@many-refs (Git 1.4866 ms; median RSS 11680→11728 KiB; 200 interleaved runs/build): 1.7 ms → 1.6 ms (3% better)branch/contains-json@git-git-10k-refs (Git 29608.1885 ms; median RSS 30504→30414 KiB; 10 runs/build): 24.3 ms → 24.1 ms (1% better)branch/contains@git-git-10k-refs (Git 29687.2210 ms; median RSS 30206→30146 KiB; 10 runs/build): 24.9 ms → 23.7 ms (5% better)branch/create@many-refs (Git 1.5300 ms; peak RSS 13672→13676 KiB; 20 runs/build): 2.4 ms → 2.3 ms (6% better)
  • ›Main keeper: make CI on main green (rustdoc, public-api)9ff05a6c

    Refreshes grit-lib's generated public API baseline so it records the ref-transaction partial-failure interfaces already present in the library. This is a snapshot-only CI repair with no runtime behavior change.

  • ›Main keeper: make CI on main green (public-api)1d054b51

    There is no submitted code change to integrate. The review workspace is byte-for-byte current origin/main at 1d054b51c; the public API snapshot repair had already landed as 9ff05a6c8.

  • ›Main keeper: make CI on main green (test)65a8d92a

    Builds the partial-clone benchmark source with one pack per commit batch regardless of newer Git repack consolidation behavior. It also keeps the fixture pack-only and invalidates cached fixtures whose pack or loose-object layout is stale.

  • ›Main keeper: make CI on main green (test)584f1832

    This change disables Git's automatic maintenance in the synthetic partial-clone benchmark source repository. That preserves one pack per generated commit batch on Git 2.56 and restores the fixture's required four-pack layout.

    Final synthetic fixture pack count: 3 packfiles → 4 packfiles (33% better)
  • ›Main keeper: make CI on main green (test)6815425f

    The partial-clone many-pack fixture now disables Git's automatic garbage collection in addition to automatic maintenance. This keeps the synthetic repository's intended one-pack-per-batch shape stable when newer Git versions decide to consolidate small packs.

  • ›Main keeper: make CI on main green (public-api)fabece4f

    Refreshes the committed `grit-lib` public API snapshot so it exactly matches clean output from the pinned cargo-public-api generator. The patch only reorders one existing `SwitchOutcome::path_collisions` line; it does not change Rust code or the exported API itself.

$ git log --oneline 29ebe004..v0.5.25compare on GitHub ↗
86d224a3Keep blobs an offload leaves in main in its promisor pack, and check the LOP before dropping
383cc378Add grit gc drop-large-blobs
5bd7f6d4Drop promised large blobs from partial clones
47c2388bSkip clone bundles for repositories with promisor remotes
d279098dServe and receive into repositories whose large blobs live on a promisor
953e741fNever lazy-fetch during fsck, and accept promised objects as Git does
dbe123b2Offload large blobs to a large-object promisor with grit gc offload
dfa79878Write pack .keep markers before publish and add a promisor rewrite
ee985273Stop stat-ing every pack per object when packing for a fetch
c5cbeb85Serve local filtered fetches in-process instead of spawning git
c8a8af4fLazy-fetch from all promisor remotes in Git order
05fd86acAccept advertised promisor remotes in fetch and clone
ca8c9d0eAdvertise promisor-remote in upload-pack and record client acceptance
7443671bPush to <owner>/<project> on the default grit host
22d6dad2Stream fetch responses and bound pack-writing memory
eaf207ecReport a pack that fails partway instead of hiding it
5f74c4f0Default grit login to grithub unless origin is on GitHub
259c2db4Serve snapshot checkouts for any CheckoutHost
58484ba8Recognize GitButler workspaces in status, log and commit
128a45caPage grit log through a pager on a terminal, with cursor tokens elsewhere
1d054b51Merge branch 'factory/status-cancel-stat-40b8'
9ff05a6cRefresh grit-lib public-api snapshot for ref transaction partial failure API
4ca53fc9Use persist_noclobber for reftable table publication
5d64a41fKeep StackCancelPoll off public DiffIndexToWorktreeOptions
66d479d3Poll ProgressSink during parallel stat preload on owner thread
e3a622a0Fix status stat scan ignoring cancel during blob preload
83c279f2Merge branch 'factory/reset-hard-perf-5655'
272bf9c6Merge branch 'factory/branch-list-json-speed'
04ffe885Fix reset --hard and merge --abort wide-tree performance
1ac1f760Merge branch 'factory/merge-conflict-memory-2312'
d0ae560bMerge branch 'factory/merge-detached-head-8155'
63f3ff8cKeep checkout journal until conflict merge index is written
1b3097daFixes #2312: single-index conflict merge checkout
4f031ffcbench: record config loading before and after the parser and revalidation changes
1ac791c2Revalidate the config session by re-statting its files
184572a6Parse config files with fewer allocations
5466297dMerge branch 'factory/fix-rustdoc-ci-5671'
b6ad0a80Fixes #2314: merge into detached HEAD like git
800be0f8Merge branch 'factory/reftable-receive-pack-batch-8b81'
a77a9636Wire receive-pack non-atomic fallback through commit_receive_ref_updates_on_store
545758d2Fix allowing_failures rename-only prepare shortcut in checked store
594bf7eaFix allowing_failures object checks in ObjectCheckedRefStore
4efd7552Fixes #2307: batch non-atomic receive-pack ref updates on reftable
b4572aaeFix rustdoc links on pathspec_wants_descent_into_tree
ff8e6bdbFix indexed reftable lookup and multi-namespace ref limits
0b43704cFix reftable stack ref listing performance
bce373b9Fix reftable table publish to never clobber existing files
2accc194Address review: real OIDs in interop stress test and hygiene exempt
52c48a26Fixes #2306: reftable readers reload stack on concurrent compaction
83e219a5Merge branch 'factory/receive-pack-ref-batch'
9387225bMerge branch 'factory/win-serve-db-long-path-2310'
a52c6f2cMerge branch 'factory/wildcard-pathspec-rev-list-2299'
981f197dMerge branch 'factory/json-revision-error-kind-5619'
e0813a92Fixes #2309: batch receive-pack ref creates in one packed-refs transaction
b237ff31Fixes #2310: open grit-serve.db with extended path on Windows
48016f4eFixes #2299: rev-list pathspec descent for wildcard directory segments
d4c82079Merge branch 'factory/colon-message-youngest-a87a'
e26b5f80Fix pick/revert JSON kind for reflog and change-id errors
68f45e79Fixes #2304: add revision_not_found JSON kind across commands
dd472f5cFixes #2300: resolve :/text to youngest committer-date match
4b77b90aReorder persist_rebase_stopped_head re-export in history mod
890b5fecValidate legacy stopped_head inference against replay base
f8898904Harden rebase continue after resolution commit
264a20c1Update public-api for RebaseSessionError::ResolutionHeadChanged
260eae02Fix rebase --continue after grit commit during conflict
c2b8ad0dMerge branch 'factory/log-pathspec-double-resolve-7bce'
d377cd4cMerge branch 'factory/fix-bare-worktree-add-5622'
7c686e74Fixes #2305: treat bare repo HEAD as not checked out for worktrees
bbeaf2bdFix subdir rev-walk pathspecs for excludes and glob magic
8e2de69cFix double cwd prefix on log/revs pathspecs from subdirectories
6e889c42Fixes #2301: honor gc config for commit-graph, pack-refs, and bitmaps
126cb2faFix patch-id stable mode for non-UTF-8 text blobs
3b7d852cMerge branch 'factory/reset-hard-recovery-hint-ac43'
101cfba2Merge branch 'factory/rebase-in-progress-errors-00f9'
cb68624fRefresh reset hard/soft CLI output snapshots for mode-aware recovery hints
b4449205Fix reset orphan recovery hint to preserve reset mode
ec580af8Fix mid-rebase misleading errors on pull, merge, pick, and branch rename
3b418e2eFix rename similarity scoring to match Git span hashes
929f50caMerge branch 'factory/log-since-filter-page-5578'
5d6c8c17Merge branch 'factory/fix-n-dry-run-hint'
feb91e79Merge branch 'factory/init-environment-2294'
fd59f514Fixes #2230: apply --since frontier on filtered log walks without -n
274d32aaHint Git-habit -n on mutating commands toward --dry-run
467d7b0bFixes #2287: stop inflating large blobs during pack reuse checks
2d1bd43cFix init Environment persistence and avoid dangling trees on failed commit
0144f496Keep clap global argument tests in sync with the command tree
86b65655bench: record branch listing before and after the clap global flag change
99512815Attach the root's global flags only to the invoked subcommand
440f8dbfFix dead-code warnings in grit-lib tests
dc14e80cRemove grit-lib public items with no production caller
48504105Drop the unused imara-diff dependency
34492b48Refresh grit-lib public API snapshot for ref store ordering
e84d7c9dMerge branch 'factory/fetch-deepen-haves'
487ff5c5Enable nextest setup-scripts for checkout RSS GRIT_BIN hook
9c3135e7Render stash show --stat from the library diffstat
de90b25aAdd RepositoryStash::diff_stat and the whitespace-ignored row rule
07d52329Give change-id failures their own HistoryError variant
2c0ac9a2Keep library errors typed in history absorb, fixup, squash and drop
5aac5c3aMerge branch 'factory/reflog-rewrite-lock-5521'
28ef335cdocs: benchmark negotiated shallow fetches
d5e88753Merge branch 'factory/fmt-rev-list-5552'
c4b11272Run rustfmt on rev_list parent_trees_slice condition
5ab40094Skip per-line String copies when building structured hunks
bf4a420cApply index patches without copying lines or the whole index
ec27dfddStage line ranges from a path-restricted diff with fewer index reads
21cbfa07Keep hard reset at-head worktree tests in default integration gate
b9eaaedaHonor GIT_OPTIONAL_LOCKS and StatusOptions.write_index for read-only status
93a4cd6eTest shallow fetches against bitmapped repositories and deepen negotiation
71dda1c2Fixes #2280 review: mixed bulk attrs test and GRIT_BIN RSS harness
38e167daFixes #2280 review: per-path bulk attrs and hard-reset tree-diff RSS
bee1d8adFixes #2280: stream wide-tree checkout writes in bounded chunks
80339b68Negotiate haves when fetching with --deepen or into a shallow repository
5642e2daSkip bitmaps when the fetching client is shallow
bf750b92Merge branch 'factory/post-integrate-fetch-fix-e4ef'
0dacfacaFix local-fetch progress phases and rustfmt after custom ODB merge
89128f9cMerge branch 'factory/sparse-upload-pack-perf-e608'
77370a99Fix clone_into for custom ODB and regenerate public API
4b678ed3Update public-api snapshot for fetch_remote_into and clone_into
0409738dFixes #2288: fetch and push through custom ODB primary stores
1762dde6Fix #2286 review: recompute reflog rewrites under lock
3d6561f2Fixes #2286: serialize reflog rewrites under ref locks
7bae7a38Fix stateful v2 UploadOutcome aggregation and guide_serve lint
9904887bFixes #2289: serve API push options, upload stats, and cancel
79f18505Merge branch 'factory/upload-pack-stream-large-blobs-a2e6'
8f7bb9c2Merge branch 'cursor/fix-rebase-rename-cache-5456-5b71'
3a644114Propagate I/O errors during verbatim pack reuse streaming
029edc29Fix sparse walk: no parent-tree skip; guard sparse completion
d3668222Fix sparse complete-tree cache to include path prefix
4a266fceFixes #2212: speed sparse:oid upload-pack enumeration
7c127895Stream upload-pack large blobs without buffering whole objects
a7362c98Box overlap transplant conflict output for clippy large_enum_variant
9f0ac5aeAddress review: hygiene metrics, replay merge path, overlap tests
5a2b28d5Fixes #2271: cache upstream renames for rebase replay transplants
65f01903Fix link_source_objects progress to count pack objects, not sidecar files
ccfb822cUpdate public-api snapshot for EnumeratingObjects progress phase.
54608916Fixes #2278: report incremental progress on local file fetch
e97f684aMerge branch 'factory/log-startup-5443'
045c658eMerge branch 'factory/ref-store-doc-5506'
1db7f263bench: record log rows before and after the log startup changes
09dc3c2eRead log walk commits through one single-pack reader
6043e73aRender plain human and Markdown log rows from summaries only
6ef9a52aList local pack indexes through the object database's own pack store
6b5cf581Parse the config cascade once per repository open
de3990ddFix rustdoc -D warnings for git_dir ref bypass docs
896b83a0Fixes #2285: document git_dir ref bypass and use Repository ref store
78fb27c3Fix review: set got_other on every absent have in v0 negotiation
9dda0145Fixes #2283: emit ACK ready in upload-pack v0 multi_ack_detailed negotiation
c762ed93Merge branch 'factory/diff-po-perf-2273'
85206193Sort DiffOptions methods in public-api snapshot.
52f1fb94Look up single tree paths through Odb::tree_entry_at_path
bb077751Add Odb::tree_entry_at_path for single-path tree lookups
512fb941Document with_no_index_stat_only in public API snapshot.
f1a6072aAddress review: hygiene exempt xdiff scratch, restore diff_paths API
b4a6bea6Fixes #2273: speed up Myers diff on repetitive text files
9a6eddb0Merge branch 'factory/ref-txn-o1-push'
8d7d2d36Merge branch 'factory/reftable-autocompact-5492'
8375446bSkip ref txn scaling ratio test in debug builds
2995b013public-api: reftable_delete_ref_with_write_options
000d6406Thread Environment into reftable ref-store write options
93e709c2Fixes #2279: run reftable auto-compaction after ref-store commits
06649e42Fixes #2281: track ref names in RefTransaction with HashSet
05c07517Fixes #2284: skip blob payloads in strict unpack verify
08f13c4eMerge branch 'factory/check-transaction-o-touched-9cdf'
3a4ffb25Merge branch 'factory/integrate-branch-short-ref'
5554fb5fFixes #2282: make ref transaction check O(touched refs)
41e930feFixes #2277: accept short branch names in integrate_branch into_ref
1bfa138eFix public-api snapshot ordering for RefStore::ref_lock_wait
b5c045acFixes #2276: parallel stat preload splits fat directories by index entry
157a819dFixes #2275: batch promisor fetch before tree diffs
99d0f51eFixes #2274: record history-last after rebase continue/skip reattach
1a064733Fixes #2181: honor filesRefLockTimeout for injected ref stores
bc943134Merge branch 'factory/win32-ref-reserved-names'
fc769feeFix ignorecase directory collision auto-stage rewriting sibling blobs
9f6e0912Fixes #2257: reject Win32 reserved loose ref paths in files store
accb7a5fFixes #2270: widen umask before pack sidecar chmod on Darwin
4854ec36Restore target cache-tree after hard-reset index align
bcbf6dfaFix hard-reset-at-HEAD worktree restore and deterministic RSS probe
02a1dc49Lower hard-reset-at-HEAD peak RSS on wide trees
9dfa4be7Address review: lockstep hard-reset index align and restore tests
97fe8288Fixes #2268: hard reset without flattening the target tree
b0617c69Merge branch 'factory/status-clean-10k-5414'
d23f90d1Read commits in grit-cli through Odb::read_commit
1815bce7Read commits through Odb::read_commit and Odb::commit_tree across grit-lib
f9813499Document virtual merge bases for criss-cross merges
de6f0168Merge several merge bases into a virtual base
1f508906Keep Git's order for merge bases with equal commit dates
1cb2f405docs: benchmark the clean-status untracked walk changes
daca7596diff: skip the per-entry refresh-check table when nothing needs hashing
3e1f0e05Release the diff index before building grit diff outcomes
c6aaaff3Pin expected rows in the uncommitted diff git-compat tests
2d0a7380Build grit diff's staged and working-tree outcomes from grit-lib
cf9bbdbaLoad staged, unstaged and working-tree diff sides in one library API
1e65b2edFixes #2264: speed up log --oneline on packed histories
d79df80cMerge branch 'factory/fix-ci-public-api-rustdoc'
22c4ce79Fix replay fast-path directory pruning and hygiene ratchet
b7a92f8bFixes #2263: cache upstream delta for rebase replay fast path
1b09f28eFix rustdoc link and refresh public-api snapshot for replay errors
43aceacbstatus: drop tracked files while listing each directory in the untracked walk
2f71eedbFixes #2269: derive tree cat types from mode bits only
d2b2221dMerge branch 'factory/pack-large-offset-o1'
684b0432Merge branch 'factory/windows-replace-retry-8e3e'
e21fa761Merge branch 'factory/win32-reserved-refs-49e0'
739acbebMerge branch 'factory/fix-pick-commit-2262'
0ffd2cb8Merge branch 'factory/blame-encoding-lossy-5387'
eb7a3638Fix Windows in-process commit index/ref replace contention. Fixes #2261
3cae0dc8Merge branch 'factory/push-delete-output'
97a1ca3cFix Windows files ref store creating unreadable reserved names
89cca995Merge branch 'factory/fix-reset-unreachable-warning-5405'
c635874fApply rustfmt to pick_sequence test
d0a6a23aLeave CommitRequest.author unset on ordinary CLI commits
1a2c3407Fix pick/revert state when grit commit finishes a conflicted step
162100c8Merge branch 'factory/absorb-head-backup-ref'
97bfc2acFix push delete human, markdown, and JSON output
9b40fbdaFix reset orphan warning tense and recovery hint
14694269Review: per-line encoding_lossy, restore dropped tests
5836a763Fix blame encoding_lossy and content_bytes for non-UTF-8 lines
2102b29aMerge branch 'factory/symref-target-validation'
46eade79Merge branch 'factory/fix-clippy-dead-rebase-helper'
70358dadpack index: O(1) v2 large-offset lookup via direct slot index
aaccba1bMerge branch 'factory/fix-merge-crlf-conflict-2259'
3704c03eFix history absorb when a backup branch points at HEAD
99dedcacRemove unused mainline_anchor_for_parallel_root to fix clippy dead_code
ae27f355Fix log-only updates with new_value: None skipping oid check
30fde6b6Fixes #2258: reject invalid symref targets in ref prepare
430e5a24Make filesystem case probe collision-safe with create_new
410fba1dAddress review: safe case probe, hash-safe dir fold, disk vs index paths
3aff5554Fix ignorecase auto-stage rewriting index path case on folding volumes
d1be414fFix incomplete-line lone CR in merge compare
dcbf6ac3Fixes #2259: treat CRLF vs LF as merge content differences
acaa4ccdMerge branch 'factory/wide-merge-index-6527'
fb265fd4Fixes #2254: single-pass merge index updates for wide branches
72939921Fixes #2251: finalize installed pack sidecar modes for shared repos
4e725e99Restore MSRV integration test and Unix rebase_exec_interrupt gating
bd304a97Fixes #2250: map commit-time ref D/F races to NameUnavailable
633ce4c8Fixes #2250: allow concurrent files ref transactions on disjoint refs
f4258f2cRefresh grit-lib public-api.txt for for_each_physical_stack_ref
da76d3c3Address reftable fsck review: store layer and worktree stacks
5bfb1093Fix reftable fsck false positives on HEAD and refs/heads stubs
6f4b012dMerge branch 'factory/rebase-exec-up-to-date-5344'
212d6e47Include stacked branches in identity exec rebase plans
692011fbFix rebase --exec when branch is already up to date
2239c9dbFix single-branch clone tag following and bare remote refs
ca4d4686Fix #2255: git rebase --continue only replays primary branch commits
5a2ba929Fix binary patch-text: retain blob bytes when force_read_content
e6e6f6c2Merge branch 'factory/fix-stat-line-align-5316'
66509e80Merge branch 'factory/rebase-merge-2245'
fe190b91Fix rebase merge replay dropping side branches and merge parents
b34bc619Fixes #2236: align stat and pickaxe counts with patch line ops
132060baFixes #2253: roll back auto-stage on hook failure
6565b24eFix rustdoc link to line_change_counts in diff core