Merge or rebase?
One less decision.

Keep the history you reviewed.
Keep the next task moving.

With Git, you choose between joining histories and replaying commits onto a new base. TOVIO’s native CLI gives you an everyday default: preserve the finished work, then update the eligible work that depends on it.

One checkout feature. Follow what land does.
A checkout feature with three stacked changesA adds the payment API. B builds a checkout form on A. C polishes the interface on B. Main has also moved ahead. Only A is ready to ship.ABCbasemain advancedreviewed API

The API is ready. The form and UI aren’t.B depends on A; C depends on B. That is a stack. You want to ship A without taking the unfinished work with it.

The reviewed API change joins main without being rewrittenAn integration commit joins main and the original commit for A. A keeps its original author and signature. The remaining stack has not yet moved in this illustration of the first part of landing.ABCbasemain advancedreviewed APInew main

Keep the exact API commit you reviewed.Because main moved ahead, land joins the two histories with a merge. A stays intact, including its author and signature. When eligible, this can be a fast-forward instead.

The remaining checkout work moves onto the new main tipB and C are rebased onto the integration commit. Their commit hashes change, but their stable Change IDs stay the same. The original reviewed commit for A remains in history.ABCbasemain advancedreviewed APInew main

The form and UI follow the new base automatically.The CLI rebases eligible descendants B and C. Their snapshots get new hashes, but their Change IDs stay the same. Continue the next task without manually rebuilding this stack.

A
Payment API
B
Checkout form
C
UI polish
Three views of one native CLI command, not three commands. Illustrative unprotected stack; cascade limits apply.

Why Git teams
have the debate.

You start a feature. While you work, main moves forward. Your feature and the team’s new work now need to come together. Git gives you two different ways to do that.

Merge: join the histories.

On divergence, Git creates a merge commit connecting both lines of work. The original commits stay intact.

main + featureBoth histories retained

You keep the evidence of how the work happened. The history graph has a branch and a join.

Rebase: replay the work.

Git recreates the feature’s commits on top of the new base. The result can be a straight line, with new commit hashes.

new main + replayed featureA linear history

You get a linear presentation. Rewriting shared commits also needs coordination with people working from the old ones.

The friction is everything around the choice.

Which policy does this repository use? What happens to the branches stacked above this one? Which hash still identifies the reviewed work? Neither Git operation is wrong. The repeated decisions and follow-up work are what TOVIO aims to take out of your day.

Preserve what’s finished.
Move what comes next.

TOVIO separates two jobs that often get tangled together: integrating reviewed work and updating unfinished work. The native CLI coordinates both through land.

tovio land payment-api --into mainShip the API lane. Keep building the checkout.
A

Land the API as reviewed.

TOVIO joins the API’s history with main, or fast-forwards when eligible. It retains the original source commits instead of recreating them just to flatten the graph.

The authorship and signatures belong to the same commits you reviewed.

B + C

Bring the remaining stack along.

The CLI rebases eligible dependent changes onto the new lane state. The form and UI get a current base; their stable Change IDs stay attached to the work.

Keep developing without a separate manual restacking routine.

A lane names a line of work, much like a branch. A change is an identifiable unit of work. The cascade is path-scoped: non-overlapping lanes can be left alone, protected lanes are never rewritten, and partial results are reported.

Less bookkeeping.
More continuity.

The payoff is practical: fewer dependent branches to repair by hand, original review evidence kept in history, and a stable name for work that moves.

The everyday difference, without assuming extra Git tooling
What you care aboutGitTOVIO
Keep the reviewed evidenceA merge retains the original commits. A rebase recreates them on a new base, with new hashes.Default landing keeps the original source commits, with their authorship, signatures, and available agent provenance.
Spend less time restackingUpdating dependent branches is a separate task. Commands, hosting services, and stack tools can help automate it.The native CLI land operation also rebases eligible descendants. Finish one piece without manually rebuilding the work above it.
Keep referring to the same workA rewritten commit has a new hash. A pull-request tool may maintain a separate conversation around it.A Change ID identifies the work separately from its commit hash. B remains B after a supported rewrite, even though its snapshot changes.

You shouldn’t need a flat graph to understand the code.

TOVIO’s merge-aware history readers follow content back to the authoring work. An integration merge doesn’t have to take the credit for every line it brings in. That makes preserving the original commits useful, rather than a reason to sacrifice readable attribution.

See how change identity works

Know what will happen.
Have a way back.

Less history maintenance should also mean less hesitation. Inspect a landing before it changes anything, then inspect the resulting stack.

Preview the landing.

tovio land payment-api --into main --dry-run --explain

See the merge base, per-file decisions, and gates without advancing a reference.

Undo a retained local landing.

tovio undo

When the landing is the next undoable operation, one undo restores it and its cascade. Local retention applies; undo cannot recall a result another peer has already observed or reverse external effects.

Explore the recovery model

The routine gets simpler.
The real decisions stay yours.

Merge and rebase remain mechanisms in TOVIO. The everyday dilemma matters less because the default handles integration and stack maintenance together.

What if my team requires linear history?

Choose it explicitly with tovio land payment-api --into main --rebase. TOVIO recreates the source commits on the target, keeps their Change IDs, and signs the new commits as the lander. You trade preservation of the original landed commit objects for a linear mainline.

This option accepts one source lane and refuses a source that already merged its target in. Read the linear-landing rules.

Does this make conflicts disappear?

No. Conflicting intent still needs a decision. In an eligible unprotected cascade, TOVIO stores the disagreement as a conflict object and continues with the remaining descendants. Both sides stay inspectable; this does not prove the code is correct or buildable.

Protected-lane conflict restrictions and other configured landing gates still apply. Understand conflicts as objects.

Will it rewrite every branch or work the same in every client?

The automatic cascade described here is the native CLI workflow. It only rewrites eligible descendants in its path-scoped cascade; protected lanes are not rewritten. Inspect reported skips or partial results and follow the suggested next action.

Other clients and entry points have their own supported behavior. Consult the land guide for the workflow you use.

Your next task is the point.
The graph can follow.

Evaluate TOVIO with a small stack: land the ready change, inspect the work above it, and follow the same Change IDs onto their new base.