What import carries over, and what it does not

What comes across

• Commit history and its full topology, including merges.
• Branches, which become lanes. A branch whose name is not a valid lane name is reported as skipped.
• Tags, as immutable tag refs.
• Author and committer identity, unless you pass --anonymize.
• File contents, including large binaries — chunked and stored natively, with no LFS equivalent needed.
• Symlinks, as symlink entries rather than as their target text.
• Submodules, as pointer entries. The gitlink's immutable object id is preserved, and the matching URL from the commit's own tracked .gitmodules rides along as an advisory hint. .gitmodules itself stays ordinary tracked content.

What does not

• Git hooks. TOVIO's equivalent is sandboxed lifecycle plugins, a different model with different guarantees. Rewrite rather than port.
• Submodule workflow. The pointers survive the round trip, but nothing fetches, resolves or populates them — there is no tovio submodule update, and the recorded URL is data, never authority. TOVIO never performs network I/O off a .gitmodules URL. For genuinely coupled repositories, meta-changes land atomically across repositories instead.
• LFS content. Import reads Git's object database, so an LFS pointer imports as the pointer text it is. There is a separate article on doing this properly.
• Git commit signatures. The history is preserved; the signatures do not verify under TOVIO's signing scheme and are not carried as valid TOVIO signatures.
• Pull requests, issues, CI runs. Those live in your host, not in Git, so an import cannot see them.

The one that surprises everyone

Import writes trees straight from Git's object database, so a .github/ directory that is in your Git history is in your imported history. But TOVIO's working-copy snapshot does not track dot-prefixed paths by default, so the first native commit you make builds its tree from a walk that never sees them.

If you want .github/, .editorconfig or any other hidden path to keep travelling with the repository, write the negations into .tovioignore before you commit. The dotfile article covers it properly.

What changes shape

Branches become lanes, which converge rather than diverge. Imported commits are given a stable chg: id derived deterministically from the Git commit, so re-importing the same history produces the same ids. What imported history cannot gain retroactively is the property those ids exist for: an id that survived a rewrite it never went through.