59 changes landed on main

Adds typed Rust representations for the factory's versioned daily benchmark report and a stable registry of 17 headline scenarios. It also adds a hidden command that validates report tags, scenario IDs, uniqueness, and peak-memory data before reports are consumed.

Adds a shell-free benchmark runner that executes argv directly in an isolated environment, optionally prepares each iteration, alternates git/grit measurements, and records wall time plus descendant-aware peak RSS. The round-2 fix makes its reported statistics reliable for even sample counts, failed iterations, and temporarily unequal ABAB series.

Adds deterministic daily benchmark fixture shapes for small, 10k-file, 100k-file, and pinned git.git repositories, including smoke-scaled variants and cache-aware preparation. The round-2 fix gives Synth100k its intended shallow wide topology instead of inheriting the legacy deep L-tier layout.

Adds deterministic benchmark fixtures for packed and loose many-ref repositories, bounded large binary histories, and deeply nested trees. The registry exposes full and smoke variants, while Rust tests verify deterministic tips and interoperability with the system Git client.

Adds a daily performance census with 13 runnable local headline scenarios and four explicitly pending network headlines. It records wall time and peak RSS for system git, candidate grit, and optionally a baseline grit, with filters, smoke mode, validation, CI smoke coverage, fixtures, and documentation.

Adds the daily worktree/history benchmark matrix and fixes four rows that previously measured the wrong operation or reused mutated state. The resulting smoke run executes 35 worktree, index, diff, blame, and revwalk cases against system Git, validates every report row, and records RSS for both clients.

Adds the daily benchmark matrix for branching, refs, maintenance, and miscellaneous repository operations, with deterministic special fixtures and Git/grit timing plus RSS capture. The round-3 fix makes commit-graph preflight prove that grit actually wrote a valid graph, while retaining system Git fsck validation.

Adds daily benchmark coverage for the common remote workflows over file and local smart HTTP transports, with Git/Grit ref parity checks before timing. The review fixes make the HTTP mirror used by prepare hooks identical to the server docroot and make incremental push inputs reproducible.

Adds a reusable compiled commit filter to revwalks for author, committer, message grep, case folding, fixed strings, BRE semantics, inversion, and caller-supplied mailmap mapping. Filtering happens inside bounded and path-limited walks so limits count matching commits while non-matching commits remain traversable, and the round-two fix makes identity matching byte-safe and preserves ODB errors.

Adds a public, clock-injected Git date-cutoff parser that returns a typed error instead of silently falling back to now. It validates relative, absolute, ISO 8601, RFC 2822, yesterday, and noon forms against system Git while keeping process-timezone-sensitive tests out of the library hygiene scan.

This refactors three-way tree merging to parse each tree once per merge and walk base, ours, and theirs together over touched paths. It also fixes the round-1 empty-subtree regression so an empty directory does not falsely trigger a directory/file conflict, while preserving Git-compatible result trees and conflict stages.

The dashboard’s log benchmark now measures a single capped Grit log invocation instead of ten paged subprocesses. Campaign paging remains unchanged and is described explicitly, while regression coverage proves the dashboard path emits 100 commits from exactly one process.

Pack indexes and reverse-index sidecars can now use memory mappings instead of eagerly copying entire files, while small or unmappable files retain owned-byte fallback storage. Opening performs cheap structural validation; full verification and lookup paths preserve typed corruption reporting, and repack drops cached maps before deleting old pack artifacts.

Packed-refs now has a read-once indexed view that binary-searches sorted files for exact names and bounded prefixes, while unsorted files retain linear fallback behavior. The files ref store distinguishes partial indexed access from a complete packed map and refreshes the view when the file stamp changes.

This replaces dense per-index parallel status/diff preload output with sparse worker batches containing only entries that require follow-up work. It also carries the status-performance stack’s compact stat representation, safe deferred index removals, untracked-cache optimization, symlink handling, and memory/performance regression coverage.

This branch resolves repository paths once, holds a per-Repository configuration snapshot with explicit invalidation, caches derived replace-ref state and loose objects, and routes ref-store selection through repository-local state. Round 3 removes an unsafe process-wide stamp-keyed ref-store cache and makes missing local config distinct from other I/O failures.

This change replaces a full-output-vector index merge with a backward adjacent-run merge that stores only the shorter run, and compacts deferred restage jobs to index positions. It also fixes the prior job/prepared-result misalignment by carrying entry indices alongside accepted batch inputs.

This change consolidates clean pick, revert, and non-conflicting merge checkout into one precomputed tree-diff path, then applies sparse merge entries and refreshed stats to the existing index. Round-two fixes narrowed implementation helpers back to crate visibility and avoid duplicate index updates during checkout.

Maps commit-graph and MIDX read storage and splits commit-graph opening from full verification so normal history operations avoid owned whole-file copies and expensive graph validation. MIDX direct reads retain checksum rejection and pack fallback, while fsck/verify retain full corruption diagnostics.

This branch consolidates diff configuration into a public `DiffOptions`, routes structured and log-patch output through shared line-hunk generation, and migrates callers and tests. Round 3 restores structured function context and replaces the Minimal/Patience paths, but Histogram still produces different hunk boundaries from Git on a broad deterministic corpus.

Moves diff target selection and structured file-diff construction into grit-lib, leaving grit-cli focused on argument parsing and rendering. It adds typed targets and argument-resolution errors, a shared `-U/--unified` formatting argument, Git-compatibility coverage, and the requested round-2 correctness/snapshot/API fixes.

Adds typed diff-status filtering, configurable line-diff algorithms, rename thresholds, and no-rename behavior through grit-lib, then exposes them in the modern `grit diff` CLI. Round three repairs exact 100% rename handling and attempts to support attached `-M30` without consuming revisions, but that parser repair still has argument-boundary regressions.

Adds a library-level fast change query and exposes cached/staged aliasing, quiet/exit-status behavior, and a stable JSON `changed` field through the CLI. The round-3 correction ensures normal human, JSON, Markdown, and `--exit-code` output builds the diff once, while only `--quiet` uses the no-hunk query.

Adds typed whitespace comparison modes to grit-lib and exposes `grit diff -w`, `-b`, and `--ignore-blank-lines`. Normalized keys drive alignment while original lines remain available for rendering, and whitespace-only modified files are removed without losing rename or mode metadata.

Adds repository-independent filesystem diffing for files, directories, mixed file/directory pairs, symlinks, executable modes, and renames, then exposes it through `grit diff --no-index` outside repositories. This review revision fixes root-path joining while retaining earlier fixes for unique directory entries, type collisions, mode classification, schema output, performance, and repository `-U`.

Adds a library-first Git-apply-compatible patch writer and exposes it as `grit diff --patch-text`, including text/binary bodies, modes, renames, worktree bytes, and documented CLI behavior. Round 3 replaces full ODB scans during abbreviation warmup with indexed prefix lookups, but the limited layered lookup can miss collisions and measured performance remains narrowly above the stated ceiling.

This makes repository paths display relative to a subdirectory on macOS even when the cwd uses /tmp or /var while canonical repository paths use /private/tmp or /private/var. Status and diff inherit the corrected library behavior without CLI-specific logic or output-shape changes.

Revision-walk and blame path operands now resolve from the process working directory while preserving repository-root semantics for `:(top)` and `:/` magic. The CLI remains thin, and the library owns the path resolution behavior for embedders.

Tightens `grit diff` positional disambiguation so unresolved names stay revisions instead of becoming path filters that produce an empty successful diff. It also handles a range followed by an unknown token by reporting that second token, while preserving range/commit plus known-path behavior.

Diff JSON now writes compact output and stores ordinary line content as one `text` field, retaining segment arrays only when inline emphasis exists. Large human diffs cap word-level work after 64 changed files; round-2 fixes make stash output mode-independent and update all affected snapshots and redaction filters.

Linked worktree add/remove now discovers the linked repository using the parent handle's configuration environment, command runner, diagnostics, and thread policy. Repository-specific discovery overrides are cleared so the linked worktree still resolves its own gitfile, index, worktree, and object location.

Partitions pending blame lines into unchanged affix lines and edited-middle lines, allowing tail-churn ranges to cross commits without a full diff. It also adds large-file full/range benchmark fixtures, compatibility checks, perf-target entries, docs, and a committed baseline.

Markdown diff sections now always identify the change status and show old/new modes when the sides differ. Empty patches for mode-only and rename-only changes no longer produce empty fences, while human output explicitly identifies deleted and renamed files.

The UNTR fast path now verifies every cached directory node it will rely on before returning cached untracked paths. A stale node forces the existing refresh path, so newly created files in Git-warmed cached directories are seen by status and commit staging.

Speeds the large HTTPS receive path by selecting platform TLS on macOS, removing redundant HTTP buffering, and reducing spool synchronization to one handoff sync. It also adds a sideband demux benchmark and documents the transport feature choice; round 3 fixes the Rustls-only lint regression without changing behavior.

The CLI now stages once and creates the commit from that staged index instead of entering a second worktree-staging pass. The ignorecase fast path resolves index paths to their real on-disk spelling, preserving case-only renames while retaining the tracked-stat scan.

This change fixes loading valid Git config values that contain escaped double quotes while otherwise unquoted, including Windows credential-helper commands. It also makes inline-comment detection use the same escape-aware quote tracking, preventing escaped quotes from hiding a following comment.

Speeds large-tree status and diff scans by grouping tracked-file metadata work by directory and reusing collapsed untracked-cache subtrees. It preserves correctness for directory-to-symlink replacements and prevents an invalid root-level UNTR collapse, with gated 50k and Git-oracle regression coverage.

This change restores the pre-affix-partition fallback for blame batches whose pending lines all lie in the edited middle, while retaining prefix/suffix shortcuts for mixed and affix-only batches. It also refreshes the large-tail blame benchmark baseline and fixes all commit attribution policy violations from the previous review.

This change restores the benchmark scenario smoke by writing the GC reset marker immediately after creating its fixture. It also halves the large UNTR test's fixture seeding work through a same-filesystem local clone and adds narrow hygiene fixes required by the CI ratchet.

This moves GitHub's OAuth device-code exchange, polling/backoff, token credential construction, GitHub HTTPS URL classification, and effective credential-helper lookup into reusable grit-lib APIs. The CLI now retains only configuration discovery, prompts, platform helper setup, typed error rendering, and output.

Serializes disk-heavy index fixtures across test binaries with a process-held advisory lock, preventing concurrent large fixtures from exhausting CI disk. The revised helper does not return until the lock is actually held, and a subprocess regression proves a second contender waits until release.

This refreshes the public dashboard’s nine release-comparison scenarios and fixes the benchmark runner so each `git diff` and `grit diff` sample sees exactly 48 modified tracked files. The paired v0.5.0/current controls are now comparable, and the reports identify grit 0.5.0 versus 0.5.14 at commit 8d6be29c.

Corrects upload-pack's deepen-relative shallow boundary calculation and repairs three independent CI-only breakages in benchmark smoke, rustdoc, and heavy-disk tests. The implementation is narrowly scoped and keeps protocol logic in grit-lib while benchmark/test support stays in supporting crates.

This change removes one obsolete argument from each of two parallel worktree-scan regression tests. The test crate now compiles against the production helper's current 10-argument signature, restoring the test, coverage, threaded-test, and Miri jobs that all failed at the same compile step.

Caches repository paths, config cascades, derived config settings, ref stores, and selected ODB/MIDX inputs per open Repository handle, then routes hot consumers through those snapshots. It adds regression coverage for config invalidation and Linux syscall counts, but currently introduces a process-global MIDX config bridge that fails the hygiene gate.

This isolates benchmark fixture scratch directories during unit tests so parallel workers cannot delete each other's repositories, and makes legacy example compilation resilient to the runner's transient linker bus errors by serializing links and retrying only recognized crash signatures. It also repairs one strict rustdoc link.

Unifies line-diff configuration behind one public `DiffOptions` API and routes structured, patch-log, tree, absorb, patch-id, and CLI consumers through one line engine. The follow-ups make Histogram hunk selection match system Git, restore structured-hunk function context, and refresh the generated public API snapshot.

Minimal diff now keeps repeatedly occurring records eligible during cleanup instead of prematurely collapsing them. This restores the two zero-context hunks expected for the upstream t4071 repeated-anchor fixture and adds a direct unit regression.

This follow-up bounds staging memory by avoiding retained worktree metadata and unconditional index-entry clones, selecting serial restage for campaign-scale indexes, and merging sorted replacement entries with bounded live storage. It also preserves the index blob only when autocrlf cleaning needs the safety comparison.

This stack gives `log` and `revs` one shared revision-selection model and makes opaque log cursors self-contained across ranges and date cutoffs. The follow-up fixes harden revwalk/ODB edge cases, restore Git-compatible left/right counting and ref order, and make cursor-only continuation work as designed.

This change makes attached rename thresholds such as `-M30` work when root global flags precede `diff`, while preserving literal dash-leading pathspecs after `--`. It adds focused unit and CLI regressions and leaves the library and on-disk/wire behavior unchanged.

Commit-graph layers and multi-pack-index layers are backed by `PackData`, allowing files above the small-read threshold to remain memory-mapped instead of copied into owned buffers. The follow-up preserves exact lookup parity with owned parsing and makes undersized MIDX stubs fall back to ordinary pack reads rather than aborting the chain.

This change replaces repeated setup, outcome conversion, rendering, and error-wrapper code across six `grit history` actions with one shared rewrite context and one outcome type. It adds two small `RewritePlan` inspection methods so the CLI no longer reconstructs mappings or rereads HEAD outside the library/ref abstraction.

This change makes `grit-bench fixtures prepare --only` accept the comma-separated fixture list used by daily-smoke CI. It adds a focused argv regression test and repairs one stale diff-library rustdoc target; the prohibited histogram implementation from review round 1 has been removed completely.

Consolidates clean pick, revert, and merge checkout around a precomputed tree merge result, reducing redundant tree/index passes. The round-4 fix removes the unsafe worktree-only index bypass and retains the faster single-pass merge path with full index finalization.

Centralizes annotated-tag traversal in two typed `Odb` methods and routes fetch, serving, reachability, refs, porcelain, and `grit show` through them. The round-two revision removes the invalid 64-tag ceiling while retaining cycle protection for pluggable object stores.

This adds a reusable grit-lib model for selecting a branch comparison base and computing its ahead/behind standing, then replaces duplicated CLI implementations in status, shortlog, branch deletion, and absorb. Ref lookup now honors Repository::refs(), including injected and reftable backends, while the rendered CLI output remains unchanged.

This branch adds `grit diff --patch-text` output that system `git apply` accepts, including binary patches, worktree/index content, quoted paths, and unique object abbreviations across layered object storage. The round-3 fixes correctly deduplicate overlapping pack and loose objects and avoid structured line-diff construction for ODB-backed commit ranges, but small-range throughput remains nearly twice Git's.