placeholderlabs/locus-commit-pool-v1

Locus Commit Pool v1

Native Git history, preserved as replayable software changes

Commit message · complete selected before-state · unified patches · native object IDs · provenance · experimental labels

Locus Commit Pool v1 is a large evidence pool for studying and training on how real software changes. Each document represents one surviving single-parent, multi-file Git commit. It keeps the commit message, the selected files as they existed before the change, the patches that transform them, native Git identities, repository context, verification evidence, and labels intended for later mixture experiments.

This is the curated candidate pool, not a finished training mixture. The stored labels let downstream work choose languages, repository tiers, change types, test-bearing edits, patch sizes, and other strata without rerunning Git acquisition.

Important: source files remain governed by the licences and terms of their original repositories. The dataset wrapper does not grant a blanket licence over the underlying code.

Snapshot at a glance

	Frozen v1 snapshot
Stored payload	3,412,022,183,341 bytes (3.10 TiB)
Repository objects	5,169 LFS-backed files, plus manifests and receipts
Storage layout	Recipe fingerprint → source split → quality band → JSONL shard
History window	Up to the latest 10,000 commits from each pinned repository head
Commit shape	Single-parent native Git transitions; merge commits are excluded
Document identity	commit-doc:{repository_id}@{commit_oid}
Schema	locus.item/v1
Run state	Frozen, safely wound down, and resumable from durable private checkpoints

Acquisition stopped before the planned 100,000-repository inventory was exhausted. This snapshot is therefore a substantial partial collection, not a claim that every planned repository was processed.

What is inside one document?

commit document
├── id                         stable repository + commit identity
├── parents                    lineage back to the traveling pipeline item
├── payload
│   ├── message                original commit message
│   └── changed_files[]
│       ├── path + raw path bytes
│       ├── status + old/new modes
│       ├── old_oid + new_oid  native Git blob identities
│       ├── before_content     selected parent-side file state
│       ├── unified_patch      transformation target
│       └── numstat
├── meta
│   ├── source                 manifest position, split, discovery routes
│   ├── repository             pinned head and bounded-history receipt
│   ├── identity               commit, parent, tree, author and time facts
│   ├── change_summary         original/retained file and byte counts
│   ├── proof                  reconstruction and replay evidence
│   └── pipeline_log           reason-coded file screening receipts
├── annotations
│   ├── programming_languages
│   ├── conventional_commit_type
│   ├── tests_touched
│   ├── patch_statistics
│   ├── possible_ai_authorship
│   ├── commit_quality_score
│   └── quality_band           01 (highest-ranked repository tier) … 10
└── provenance                 clone URL, object IDs and payload SHA-256

Every stored payload receives a canonical SHA-256. Raw path bytes are retained alongside a readable path. Any non-UTF-8 decoding is made visible through *_lossy flags rather than being silently hidden.

Read a document

The pool is intentionally sharded. Stream only the objects you need instead of downloading the complete snapshot:

import json

from huggingface_hub import HfFileSystem

fs = HfFileSystem()
path = (
    "datasets/ahnaftaz/locus-commit-pool-v1/"
    "shards/0a582f09ed89/split-07-of-10/band-01/"
    "commit-doc-00000000-c47af23f2af7a413.jsonl"
)

with fs.open(path, "rb") as stream:
    document = json.loads(stream.readline())

print(document["id"])
print(document["payload"]["message"])
print([change["path"] for change in document["payload"]["changed_files"]])

Shard paths follow this contract:

shards/<recipe-fingerprint>/<source-split>/<quality-band>/commit-doc-*.jsonl

Keep documents intact during packing. A common training view exposes the message and parent-side file state as context, then applies loss to the patch, but renderer, masking, deduplication, and mixture weights are deliberately downstream decisions.

How the pool was built

The public recipe is intentionally explicit. Operations inside one repository run sequentially; repositories run concurrently.

Show the exact pipeline spine

Pipeline([
    FetchFrozenReachableTargets(),
    ParallelForEach(
        partition=EachRepositoryTarget(),
        steps=[
            # Pin and enumerate one bounded native Git history.
            DownloadCommitHistorySlice(),
            DownloadGitAttributeFiles(),
            ReadCommitsFromHistorySlice(),
            SkipMergeCommits(),
            SkipCommitsWithParentBeyondCutoff(),

            # Screen changed files while retaining reason-coded receipts.
            DropChangedFilesInJunkFolders(),
            DropGeneratedChangedFiles(),
            DropLockfileChangedFiles(),
            DropBinaryChangedFilesByPath(),

            # Hydrate exact Git objects and inspect their bytes.
            DownloadChangedFileBlobs(),
            AttachBeforeFileContents(),
            DropChangedFilesOverMaximumCharacterCount(),
            DropChangedFilesWithOverlongLines(),
            DropChangedFilesFailingCharacterCompositionCheck(),
            DropBinaryChangedFilesByContent(),

            # Render the selected parent-to-child edit.
            RecordCommitSizeAgainstCandidateCaps(),
            RenderCommitPatches(),
            DropAfterFileContents(),

            # Attach experimental evidence without changing the payload.
            AnnotateConventionalCommitMessage(),
            AnnotatePossibleAiAuthorship(),
            AnnotateCommitPatchStatistics(),
            AnnotateChangedFileLanguages(),
            AnnotateTestsTouched(),
            VerifyCommitReplayFidelity(),
            AnnotateCommitQualityBand(),

            # Emit one holistic document per surviving commit.
            AssembleCommit(),
        ],
    ),
    SaveToHuggingFaceWithFallback(),
])

The collection is anchored to recorded repository heads. Native object IDs bind the before and after sides of each selected change. Production replay auditing deterministically reapplies a sample of patches against their stored before-state; replay_verified and replay_mismatch are explicit outcomes. parent_reconstructed means the parent-side evidence was assembled from the native history but the document was not in the replay sample—it must not be read as a stronger claim.

Understanding the labels

Quality bands are storage and experimentation strata, not universal judgements about whether a commit is good training data. Band 01 begins with the strongest repository-discovery tier under rubric v2; commit-level deductions record facts such as empty messages, excessive screening, cap violations, lossy text, or replay mismatch. The complete score components and deductions are stored so future recipes can re-rank documents without repeating acquisition.

Likewise, possible_ai_authorship only records explicit name or trailer signals known to the heuristic. It is not a classifier and should not be treated as proof that a human or model authored a change.

Limitations and responsible use

• Original licences govern. Review repository- and file-level licence evidence before redistribution or model training.
• This is not the final corpus. Global exact/near deduplication, benchmark decontamination, exposure caps, rendering, tokenization, and mixture selection belong to the later corpus stage.
• The source inventory is intentionally biased. Ranked repositories, organisations, language lists, and package/ecosystem signals shaped discovery; this is not a uniform sample of GitHub.
• The selected view can omit files. Generated, vendored/junk, lockfile, binary, oversized, overlong-line, or composition-failing files may be screened with receipts. Commits with no surviving file are absent.
• Merge commits are absent. v1 represents single-parent changes only.
• Safety review remains necessary. Public Git history can contain personal information, credentials, malware, prompt-injection text, or other unsafe material. Do not execute repository content outside an isolated environment.
• Text fidelity is explicit, not perfect. Inspect the path, message, patch, and before-content *_lossy flags when exact bytes matter.

Suggested citation

@misc{locus_commit_pool_v1_2026,
  title        = {Locus Commit Pool v1},
  author       = {Placeholder Labs},
  year         = {2026},
  howpublished = {Hugging Face dataset},
  url          = {https://huggingface.co/datasets/ahnaftaz/locus-commit-pool-v1}
}

---

Built as an inspectable evidence pool: native identities in, durable receipts throughout, mixture decisions later.