README.md

---
pretty_name: Locus Commit Pool v1
task_categories:
  - text-generation
tags:
  - code
  - git
  - commits
  - software-engineering
  - pretraining
  - multi-file
  - jsonl
license: other
---

<div align="center">

# Locus Commit Pool v1

### Native Git history, preserved as replayable software changes

[![Snapshot](https://img.shields.io/badge/snapshot-2026--08--17-7257ff?style=for-the-badge)](#snapshot-at-a-glance)
[![Stored data](https://img.shields.io/badge/stored_data-3.10_TiB-16a085?style=for-the-badge)](#snapshot-at-a-glance)
[![Format](https://img.shields.io/badge/format-JSONL-2f80ed?style=for-the-badge)](#read-a-document)
[![Source](https://img.shields.io/badge/source-Native_Git-f05032?style=for-the-badge&logo=git&logoColor=white)](#how-the-pool-was-built)

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

</div>

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?

```text
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:

```python
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:

```text
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.

<details>
<summary><strong>Show the exact pipeline spine</strong></summary>

```python
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(),
])
```

</details>

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

```bibtex
@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}
}
```

---

<div align="center">
Built as an inspectable evidence pool: native identities in, durable receipts throughout, mixture decisions later.
</div>