Skip to main content
Version: 0.1.148

Upstream sync

Upstream sync brings changes made outside the platform into the project. It exists because the modernized codebase is a real repository your developers also work in, and a platform that assumed otherwise would overwrite their work.

When you need it​

  • A developer committed directly to the modernized repository.
  • Another team merged something into the base branch.
  • A project combining several source repositories, where each moves on its own.

What it does​

Inbound sync builds the project's workspace from the source repositories as they now stand. For a combined project, commits are pulled from each source repository into the combined feature branch, and work done in the combined workspace is pushed back out to the repositories it belongs to.

That round trip is the point: developers keep working in the repositories they know, and the platform keeps a coherent view across them.

Reading a sync​

Each sync is recorded with what it brought in. Open one to see which repositories moved and what came across — worth doing when an implementation starts behaving differently for no reason you can see in the platform.

Feature branches and a base that has moved​

A base branch that moves after a feature branch was cut is normal, not an error. The base branch can be merged into a feature branch to bring it current, and a reused feature worktree is kept current with the base branch automatically.

Bringing one feature branch up to date​

When a feature's branch is behind its base, the feature's page says so — "<base> has moved on since this branch", with how many commits — and offers Merge <base>. It is there from the moment the feature has a branch, whatever its status: a feature still being implemented can take in a fix from the base, such as a corrected dev configuration its preview needs. The base is the same one Update feature branches uses: origin/<base> in a pull-request project, combined main in a combined workspace (synced first), and the project's own integration branch in a direct-mode project.

The merge asks for confirmation, then runs as a job. A clean merge runs no tests; a conflict is handed to the conflict-resolution agent, which must get the test suite passing before its resolution is kept, and a conflict it cannot resolve leaves the branch exactly as it was. It opens no pull request. A direct-mode branch that is already on the repository has that copy updated. A running implementation preview picks up the merged code when it restarts.

While the feature's own implementation, prototype or verification is running, the button reads Merging…: the run pauses, takes the base's new commits and carries on. Uncommitted changes nobody has open in Repave IDE are set aside for the merge and put back. The button is disabled, and says why when you point at it, while something else is working on the branch: another job or a UAT session running on it, a merge left in progress, or uncommitted changes open in Repave IDE. Untracked files never block it. A feature with an open pull request is brought up to date from its pull request instead.

In pull-request mode, a base branch that moves before the pull request is opened is handled rather than producing a stale request.

Updating every feature branch at once​

When the base branch changes something every branch needs — a compose file, a test runner, a toolchain pin — Update feature branches in Project Settings → Integrations brings that change into every feature branch in one go, whatever state the feature is in: in progress, merged, or a prototype not yet implemented. It sits beside Sync now in the Source repositories card for a combined workspace, and in the GitHub Integration or Git connection card otherwise.

Before you press it, the card lists which feature branches are behind the base and by how many commits, compared with the base as it was last synced or fetched. The button counts only those branches.

Pressing it and confirming:

  1. Brings the base current first: a combined workspace syncs its source repositories, a pull-request project fetches its base branch, and a direct-mode project uses its own integration branch.
  2. Merges the base into every feature branch, one at a time. It merges and never rebases, so branches under review keep their history. A clean merge runs no tests. A conflict is handed to the conflict-resolution agent, which must get the test suite passing before its resolution is kept.
  3. Pushes what the mode needs: a combined workspace pushes each published feature's combined branch (client pull requests are not changed), and never over commits someone pushed to it from outside Repave: that branch reads Failed and says so, and the feature's next Push brings them in; a pull-request project pushes the branch of every feature with an open pull request, which updates that pull request without re-running Repave's tests; a direct-mode project pushes only branches that were already on the repository.

Each branch then reads Updated, Already up to date, Skipped with the reason (no worktree, a job or a UAT session running on it, uncommitted changes to its files), or Conflict: needs attention. A conflict the agent could not resolve leaves that branch exactly as it was; resolve it in Repave IDE from the link on the row or on the feature's page, then commit. The row then reads Conflict resolved.

The notice on the feature's page goes away once the branch contains the commit that conflicted, and it does not come back when the base gets newer commits; if those conflict too, the next update says so. To close the notice before then, use its ✕: it stays closed in your browser until a later update leaves the branch in conflict again. Every red error on a feature's page can be closed the same way.

A dev stack or test database already running in a Repave IDE session keeps its old configuration until it is restarted, so restart them after an update that changed one.

Repave keeps them current on its own​

You rarely need to press the button. Repave runs the same update by itself whenever the base moves — a feature merged, a pull request merged on the repository, a commit to the base — usually within a minute. Every five minutes it also fetches the base, so a change pushed straight to the repository is picked up too; a combined workspace is synced then only when one of its source repositories has moved. Branches of Repave IDE worktrees that build on nothing are kept current the same way. Such a run reads Updated … automatically on the card, and Last automatic update once the card goes back to listing what is behind.

An automatic update works exactly like pressing the button, with these differences:

  • A branch whose implementation, prototype or verification is running takes the base through that run: the agent pauses, the base is merged in, and the agent carries on, told what came in.
  • Uncommitted changes nobody has open in Repave IDE, including what a stopped run left, are set aside for the merge and put back. A stopped run is told what came in when it is resumed.
  • A branch that is otherwise in use — another job or a UAT session running on it, a merge in progress, or uncommitted changes open in Repave IDE — is left alone and updated on the first check after it is free.
  • In a pull-request project, a branch whose pull request is open, and every branch of a project with no base branch configured, takes the base only once nothing is using it: its running work is not paused, and its uncommitted changes are not set aside.
  • A conflict the agent could not resolve is not tried again on its own. The branch keeps reading Conflict: needs attention, here and on the feature's page, until someone resolves it in Repave IDE. Pressing Update feature branches gives the agent another try.
  • A branch that failed, or an update that stopped, is not retried until the base moves again.

In a pull-request project an automatic update pushes to open pull requests, as the button does. That updates the pull request and starts your repository's own checks.

In a combined workspace, a feature that changes only files outside every source repository — such as docker-compose.bdd.yml at the workspace root — opens one pull request, on the combined repository, listed as workspace. The change reaches the base when that pull request merges.

Conflicts​

A conflicted merge into the integration branch leaves the checkout clean. You do not end up with a half-applied merge in the workspace that somebody has to unpick — the merge fails as a unit, and a failed merge job does not mark the feature itself as failed.

Resolve the conflict the way you normally would, in Repave IDE or locally, and merge again.

Where a project is linked to GitHub, the link maintains itself: it pushes on creation, syncs both ways, and pushes again at merge time. You should not need to move branches by hand to keep the two in step.