A finding should have a history you can follow.

A research note can look tidy while hiding a messy history. Which source supported the sentence? Was that the original file or a later extraction? Is the paragraph the one everybody agreed to publish, or simply the latest text someone happened to type?

ReGit starts by making those different things visible. It is a shared research workspace built with Amrit Kang at Gradient Rush Hackathon: mixed source files, derived artifacts, collaborative drafts and explicit repository history.

The live page and the citable page

Working together means text changes continuously. A CRDT-backed draft is useful for that moment: people can edit, see awareness and return to their working state. Publishing needs a firmer boundary.

ReGit keeps the live draft independent from the immutable snapshot. Committing the current file and publishing it into the repository are explicit operations. A reader following a citation should be able to recover the referenced version, even after the team has continued editing.

The local demo uses SQLite metadata and references alongside a filesystem object store. Blobs are addressed by content and written atomically. Branch movement checks the expected head instead of assuming nobody else changed it while a request was in flight.

The part I can point to in the source

My core work includes the sentence-level three-way merge. Its job is intentionally narrower than asking an AI to rewrite two competing drafts into something plausible. Given a base and two versions, the merge should combine independent changes predictably and expose incompatible edits.

For an illustrative example, imagine a paragraph with two sentences. One person corrects the date in the first sentence; another clarifies the second. Those changes can often coexist. If both people rewrite the same passage differently, there is a decision to make. The merge should not hide that decision inside confident new prose.

The implementation is a deterministic pure merge function. A clean merge creates a two-parent commit; conflicts require explicit resolution before the branch moves. Reference updates check the expected parent state, so resolving a conflict is not permission to overwrite newer work silently.

Evidence needs an address

Provenance is modeled as a path from claim to commit to artifact to source. This is more useful than attaching a loose URL after writing a paragraph: it records which preserved material supported which version of the finding.

The current lightweight implementation can search with keywords and return citations without requiring an embedding service. Optional vector functionality exists around the project, but it is not necessary to explain the verified default workflow.

Original files remain retrievable even when the parsed representation is different. Keeping a raw PDF or uploaded file is a separate responsibility from extracting useful text from it. That distinction makes later inspection possible when an extraction turns out to have missed context.

A shared prototype with a deliberate scope

ReGit combines React and TypeScript with FastAPI, SQLite and local content-addressed storage. The demonstration editing identities are not a production account system. Sentence-level prose merging is also not the same claim as merging an arbitrary PDF or a whole Git code tree.

Amrit’s work is substantial, and the project is team-built. For me, the lasting thread is the merge and provenance boundary: collaboration can stay fluid while the evidence behind a published statement stays recoverable.