Skip to main content
Version: 0.1.155 – latest

Repave IDE

Repave IDE is a full editor in the browser, running against the same workspace the agents use. It is how you do the part of the work that is quicker to do yourself, without leaving the platform or cloning anything.

Opening a session​

Open it from a feature, from a module, or from Repave IDE on the project. A chooser asks which codebase you want, because there is usually more than one:

  • the modernized codebase on its integration branch,
  • one of your own worktrees — a branch for a change that is not a feature (see below),
  • a module worktree — the one branch a module's features are built on together, or
  • a feature worktree — the branch a particular feature is being implemented on.

A module and its features share one worktree, so Open in Repave IDE on the module's page, on the module's card in the chooser, or on any of its features opens the same session. On the module's page and its card, the button stays disabled until the module's first implementation run creates that worktree, and says so.

Picking the wrong one is the common first mistake: edits made on the integration branch are not part of the feature you thought you were editing.

A progress page covers the start-up while the session comes up.

To work on a feature in your own VS Code instead, where a project has turned it on, see VS Code on your computer (experimental).

Worktrees for changes that are not a feature​

Not every change is a feature: a dependency bump, a build fix, a README. For those, make a worktree — your own branch, opened in Repave IDE like any other — from the Worktrees section of the Repave IDE page, directly under the modernized codebase.

  1. Click New worktree, type a name, and press Create. The branch is named for you — "Bump log4j" becomes work/bump-log4j — and cut from the project's integration branch.
  2. Click Open in Repave IDE on the new row and make your change.
  3. Land it: Create PR when the project merges through pull requests, or Merge to the integration branch when it merges directly. Merging directly asks you to confirm first.

Create PR has the Pull request writer agent read your change and write the pull request's title and description. If it cannot, no pull request is opened and the row says why; press Create PR again.

Each row says where the branch stands — how many commits it is ahead of and behind the integration branch, and how many files are uncommitted — and carries the other actions:

  • Push sends the branch to the repository. Anything uncommitted is committed first, as "name: changes from Repave IDE"; commit in the editor yourself if you want your own message. Once a pull request is open, pushing updates it.
  • ⋯ → Pull brings in commits someone else pushed to the branch.
  • ⋯ → Merge from the integration branch brings the worktree up to date.
  • Stage puts the worktree on the project's staging branch, next to the features and modules staged there, the same way Stage does on a feature's page. Anything uncommitted is committed first, as Push does. The button becomes Staged once it is there, and Update staging when the worktree has changed since.
  • ⋯ → Delete removes the worktree and its local branch, and closes any editor open on it. The branch on the repository and any open pull request are left as they are.

A worktree you cut yourself in a session's terminal (git worktree add … -b my-branch) is listed here too, marked made outside Repave, with the same actions. The first one you use — Push, Stage, Create PR, any of them — makes it a Repave worktree, and from then on it is like any other: Delete is offered, and landing it removes its folder and local branch. Until then Repave leaves the folder alone. A worktree with no branch checked out (a detached HEAD), and a folder one of Repave's own jobs uses, stay under Other worktrees, where they can be opened.

Each daily test fix has a worktree here too, named for its run's day, for example Daily tests fix · 4 Nov, on a branch of its own. Its actions wait while the fix is working; the same row is on the run's page.

Pull and Merge from need a clean worktree, so push or commit first. If the merge conflicts, it is left in the worktree for you: the row names the files and shows merge in progress until you resolve them in Repave IDE and commit. A merge into the integration branch that would conflict is not made at all — merge from the integration branch first, resolve there, then merge again.

In the editor's own Source Control view, a feature or worktree branch follows its own branch on the repository once Repave has pushed it, and nothing before that, never the integration branch. The ahead and behind counts there are about the branch itself. Push and pull through Repave as above: the editor does not sign in to the repository.

Nothing about a worktree is generated or tested by Repave: it is your change, reviewed like any hand-written one. When its pull request merges, the worktree is removed and the page says so.

When a worktree's pull request fails a check​

Once a worktree's pull request is open, its row shows the same Checks and SonarCloud lines a feature's pull request panel does (see Checks on a pull request). When a check fails, or SonarCloud's quality gate does, Repave fixes it by itself, as it does a feature's:

  • The row reads Repave is fixing the pull request…, and its actions wait until it is done.
  • The fix is made in a copy of your branch, then merged into your worktree. Your uncommitted edits are left exactly as they are: they are never committed or pushed. Only the fix's commit is pushed to the pull request, by the worktree's own Push.
  • If the fix needs a file you are editing, nothing is merged and the row says which files: "Repave's fix changes files you have uncommitted edits in: … Commit or discard those edits, then press Fix again."
  • If someone pushed to the branch while Repave was fixing it, the fix stays committed in your worktree and the row says to Pull, then Push.
  • Once Repave's fix failed, Fix again starts it again, with an optional instruction for the agent. Only someone who can edit the project sees it.

When a worktree's pull request conflicts with main (or whichever base it was made from), Repave resolves that first, by itself, since your provider runs no check until the conflict is gone:

  • It merges main into the worktree, as Merge from main does. A conflict goes to an agent, which resolves it as it does for a feature's branch, and the merge is pushed. The row reads Conflicts with main · resolving meanwhile.
  • The merge is made in a copy of your branch, then brought into your worktree. Your uncommitted edits are left exactly as they are, including ones you make while it runs: they are never committed or pushed. If the merge changes a file you are editing, nothing is merged and the row says which files: "Repave's merge of main changes files you have uncommitted edits in: … Commit or discard those edits, then press Fix again."
  • If the agent cannot resolve it, the worktree is left as it was, and the row lists the files: "Repave could not resolve the conflicts with main in: … Resolve them in Repave IDE: Merge from main, then Push." Fix again gives the agent another try.

Review comments on a worktree's pull request are addressed the same way: click the comment count on the row, then Address N comments (see Review comments).

On a combined workspace the modernized codebase cannot be edited, so worktrees are where a change that is not a feature is made. Push and Pull go to each source repository the change touches, with the same preview a feature's push shows, and Create PR opens one pull request per touched repository, each described by the Pull request writer for its part of the change. Files outside every source repository's folder (the test harness, step definitions, root scripts) get a pull request of their own on the combined repository, listed as workspace. It is based on where the worktree started, so if someone changed the same file on main since, your git server shows the conflict. Its description asks for it to be merged after the others. The worktree is removed once every one of them, the workspace pull request included, has merged.

On a combined workspace, each repository's pull request has its own Checks and SonarCloud lines, inside the list the PRs badge opens; the badge shows ⊗ when any of them fails. One fix covers every repository, and its Push goes to each one it changed. SonarCloud is read for a repository only when Settings names its SonarCloud project (see SonarCloud).

Opened IDEs​

Every session open on the project is listed at the top of the Repave IDE page, under Opened IDEs, with who opened it and when. Each one's Stop, Restart and Open in Repave IDE are on its row; the codebase cards below only open.

Each row also shows how much memory the session is using against its limit, in two parts:

  • Editor — the IDE itself: the editor, its terminals, and anything run in them, such as the test browser.
  • Docker — everything started from the IDE terminal with Docker: the dev stack, test databases.

A bar turns amber at 90% of its limit. When a container reaches its limit and the kernel has to step in, the row says Out of memory and names the limit to raise. The Editor meter counts the processes killed since the session started. The Docker meter says "Hit its memory limit" without a number: what Docker runs sits in containers of its own, where the kernel's count cannot be told apart from a container reaching a cap it set itself. Both limits are under Container resources in the project's General settings — Repave IDE session for the editor and Docker sandbox for Docker. A new limit applies when the session restarts, so restart it from its row afterwards.

If the folder an IDE has open is removed while it runs, the editor is left showing an empty workspace. Its row then says Workspace removed and is listed first, and Restart opens the current workspace in a new tab straight away, with no confirmation, since nothing is running in the empty one. When the workspace itself is gone, for example because the feature was merged, only Stop is offered.

When a feature's workspace cannot be opened, the chooser says why:

  • the feature has no approved To-Be Gherkin yet, so there is nothing to open. Approve it first;
  • another git checkout is in the feature's worktree folder, so it was left alone. Move it aside and open the feature again;
  • the worktree could not be prepared. Opening it again retries, and the reason is in the server log.

What is already set up​

A session is not an empty editor.

  • The Repave CLI is signed in, and stays signed in for as long as the session runs. You can read the project's scenarios, settings and decisions from the terminal without authenticating.
  • Git is configured. You can commit without setting up an identity first; commits the platform writes carry the platform identity.
  • Claude Code is available, signed in the way your project settings say, sharing the project's memory, and told which feature the session is for. When the project's sessions use the project's credential, the session starts with Claude Code's first-run setup done, the project's API key already approved, and the Claude Code panel's sign-in prompt turned off. Codex is available too, with a Repave plugin of its own. Both come with the Repave commands — /repave:implement, /repave:test and the rest — each explained in Repave IDE commands. In Codex a command is /<name> without the prefix. A Codex skill or prompt you wrote yourself under the same name as one of Repave's is kept, and the terminal says Repave's was not linked. Commands and skills a project edited or added on the Skills page come with the session too, and a change made there while the session is open reaches it without a restart: a new conversation has it, and an open Claude Code conversation says which skills changed and asks you to run /reload-plugins.
  • A browser the developer and the agent share, with a viewer inside the IDE, so you can watch what an agent is looking at.
  • Dev mode runs the application, and the preview is reachable from your browser through the platform rather than needing a port open on the host.
  • The feature's target-stack prototype, when it has one — it is already in the workspace; see below.
  • Your worktree is protected. Repave locks the worktrees it creates, so git worktree prune run in one session never drops another feature's worktree, and git worktree remove on a Repave worktree is refused with the reason "managed by Repave". Before Repave removes or resets a worktree that has uncommitted changes, it keeps a copy of them on a git ref named refs/repave/wip/<branch>/<time>. To bring one back, list them with git for-each-ref refs/repave/wip/ and run git checkout <ref> -- . in the worktree.
  • The feature's .feature file, in a feature session whose To-Be Gherkin is approved. It is written to the project's features path when the worktree has none, and never over a file that is already there, so reopening a session cannot replace your edits. To take a newer version of the scenarios into an existing file, run /repave:feature-file in the session.
  • The project's mounted files and environment variables, from the Repave IDE card in Project Settings: see Settings. A script that needs a file from the server or a variable set before it runs, such as a test runner that loads a database image, runs in the session as it does for an agent.
  • Port 8080 is free. The editor itself listens on port 13337 inside the session, so the project's own application, or a stack a test script starts, can use 8080.

The target-stack prototype is in the workspace​

When a feature was prototyped on the project's own stack, that prototype is the first work on the feature's branch — so a session on the feature opens with it already in the workspace, as working code in the framework the project is being modernized into. git log shows where its commits end.

Build on it rather than deriving the screen a second time from the design: its routing, its component breakdown and its state shape are the structure the implementation should keep. Where the two disagree on visuals, the active design wins. Claude Code and Codex in the session are told the same.

PROTOTYPE-DUMMY markers mark what the prototype built to demonstrate the screen rather than to work — fixture rows, a button that only shows a toast, a hardcoded list — and name what should replace it. Replace each one with the real thing and delete the marker; the feature cannot be merged while one remains.

The browser viewer​

The viewer streams the shared browser into a panel in the IDE, with the open tabs in a strip along the top. You can click and type in it as you would in your own browser.

  • Dialogs are answered in the panel. When the app opens an alert, a confirmation or a prompt, it appears over the page, headed with the app's host, for you to answer. A dialog the agent answers first closes in the panel too.
  • Dropdowns, date and colour fields, and suggestions open in the panel. The browser draws their lists and pickers outside the page, where a stream cannot show them, so the viewer draws them instead, over the page where the control is. Choose an option, pick a date or a colour, or click a suggestion, and the app receives it as it would from its own page.
  • A page that stops answering says so. The header reads Page not responding — often a dialog that opened while you were on another tab. The reload button (⟳) loads the page again, and the tab strip stays, so another tab is one click away.
  • The page is laid out at the size of the panel you are using. If the panel is open in two places — two IDE windows, or the IDE in two browser tabs — the one you clicked or typed in last sizes the page. The other shows the same page whole, scaled to fit, with its size (for example 1280×720) beside the address; click in it to size the page there instead. The agent cannot resize this browser: it checks narrow layouts in a browser of its own.
  • A page something else gave a fixed size is shown whole, scaled to fit the panel, with its size beside the address — for example when you attach your own DevTools or Playwright to the browser and emulate a device.

The legacy app​

When the project's legacy Windows desktop app is set up, Claude Code and Codex can drive it, and you can watch and drive it in the Legacy App panel (Repave: Open Legacy App). See Use it in the Repave IDE.

The Repave sidebar​

A sidebar specific to this product, not to the editor:

  • Scenarios — the feature's Gherkin, without switching back to the web app.
  • BDD Runs — test runs, with a Trace Viewer tab for looking at what a run actually did in the browser. The viewer runs the Playwright your test project has installed; if it has none, the tab says "Couldn't start the trace viewer: … has no Playwright installed. Run npm install there, then try again."

Pushing from the session​

You do not have to leave Repave IDE to push. In Claude Code, run /repave:push-to-remote (/push-to-remote in Codex). It pushes the branch you have checked out — a feature's or a worktree's — exactly as that feature's or worktree's Push button does:

  1. Anything uncommitted is committed first, in the session, so you see the commit.
  2. On a combined workspace, commits pushed to the branch in the workspace repository from somewhere else, such as your own computer, are merged in first, so they are pushed and split too. If they conflict, nothing is pushed, and you are told to merge the branch's -repave copy on your computer.
  3. The branch is pushed — on a combined workspace, split into each source repository it touches — and you get one line per repository: pushed, no changes, not pushed, or failed and why.
  4. On a combined workspace, a source repository whose branch has commits that were not made in Repave is left alone. The command pulls those commits in and pushes again; if the branch still differs, you are asked whether to overwrite it. Nothing else is asked.

No pull request is opened. /repave:pull-requests opens them, the way Create PR does, and /repave:git-pull pulls commits made outside Repave or merges the base branch in, the way Pull and Merge from do — all without leaving the session. Run git push yourself and a combined workspace's source repositories never receive the change; the command is how they do.

Any other branch is pushed too, except the one Repave merges into (usually main), which goes in through a pull request instead:

  • A branch Repave's own job made, such as the daily test fix's: your commits go into its open pull request, or open one if none is. The pull request's description is left as Repave wrote it. The job's next run starts that branch again from the base branch, so do not leave work only there.
  • A branch you cut yourself: on a single repository it is pushed under its own name. On a combined workspace it becomes a worktree the first time you push or pull it. Either way it is in the Worktrees list with Push, Pull, Stage and Create PR, like any worktree — and once it is a worktree, Delete there removes its folder and local branch, as it does for any worktree.

Nothing is force-pushed: if the branch moved on the remote since you last pulled, the push says so and changes nothing.

The same push is available as repave push in the terminal, with --preview to see what would happen first.

Working alongside an agent​

You and an agent can be in the same workspace. The practical rules:

  • An agent implementing a feature works in that feature's worktree on that feature's branch.
  • A reused worktree is kept current with your base branch, so you are not editing against something stale.
  • If you implement locally with the developer plugin, the same gates apply as on the platform's own pipeline — including that local implementation is gated on a concluded preflight. The plugin does not get a shortcut the platform does not have.

Session lifetime​

A session's home directory outlives its container, so a restart does not lose your shell history, your editor state, or files you left outside the repository. Sessions are reconciled and cleaned up at platform start-up, so a session left running through a restart does not linger as a ghost.

Every session of a project is also stopped once a day, at 06:00 server time unless the project says otherwise. The stop is like pressing Stop: files in the workspace are kept, while open editors close and running terminals and processes end. Open in Repave IDE afterwards starts a fresh session. A session that is still starting at that moment is left alone. To change the time or turn the stop off, see Project settings.

When a session ends while its tab is still open, the editor loses its connection. That happens when someone presses Stop or Restart, when the daily stop runs, or when the platform is upgraded. Reload the tab to get back to the same workspace: it joins the session running there now, or starts a new one, as Open in Repave IDE does.

Next: Test runs and reports.