Implementing a feature
Implementation takes a feature's to-be scenarios and writes the code. You launch it, and then your job is to answer what it asks and judge what comes back.
Preflight: the questions before the work
Implementation does not start by writing code. It starts by asking you what it cannot decide from the specification — a preflight clarification, answered per feature.
- Answers you have not submitted are auto-saved, so a long preflight survives a closed tab.
- An answer can carry per-option detail, or your own answer where none of the options fit.
- Decisions are kept, per feature and per launch, on the Decisions page.
- Preflight runs once per feature. Every later Preflight or Implement keeps the answers you already gave, whether the earlier attempt was paused, discarded, failed or finished, and whether it was this feature's own run or a module run that included it. If nothing preflight reads has changed, nothing is asked: Implement starts straight away, and Preflight is ready to implement as soon as you open it. If something has (the Gherkin, the validation rules, the database policy or your instructions), preflight checks only that change and asks only what it raises. Often that is nothing. A preflight you stopped part-way picks up where it stopped, with your unsubmitted answers still there.
- To answer every question again from scratch, start Preflight and tick Ask every question again. The option appears only when the feature has earlier answers to set aside.
A refused launch is an answer, not a fault. If preflight concludes the feature is not ready, the refusal says so, and the thing to fix is usually upstream in the specification. The same goes for a preflight that cannot start: the Start preflight dialog names the reason, such as an application shell that still has to be implemented and merged, rather than asking you to try again.
Once preflight concludes, Implement opens the same Implement dialog as everywhere else, now that preflight has told you what the feature involves. Choose the verification, the model, and the spend limit, add reference images, and give additional instructions. The instructions preflight ran with stay in place, and anything you add goes to the implementation without running preflight again. The model is locked for the run, so a launch cannot silently change models partway through.
The verification choice appears only when your project turns on Allow implementing without behavior tests in Project Settings. Implement without Behavior Tests is selected by default: the agent writes the application code only, and the behavior tests are written after you accept it. Nothing checks the code before you have looked at it. When you then choose Write Tests, the checks of an implementation with behavior tests run once the tests pass: the review that the tests prove their scenarios and every scenario is done, your project's validation rules, and the code review. What they find goes back to the agent writing the tests, to fix before the feature completes. The UI, API and database schema checks do not run then: you have already walked the screens. Implement with Behavior Tests has the agent write and pass the behavior tests before handing the work to you. The dialog remembers the last choice you made for the project in this browser.
If you tick Start implementation when preflight is done when you start a preflight, nobody presses Implement afterwards, so Start preflight asks for the verification and spend limit then.
The design doc: the plan you approve
A project can ask for a design doc for every change before any code is written. Turn on Write a design doc before implementation under Settings → Implementation; it is off by default, and with it off Repave implements straight after preflight, with none of the steps below. With it on, Repave writes the change's design doc after preflight and waits for you to approve it; nothing is implemented until you do.
A change is one request: what you asked for in Add feature, and every scenario it added or edited, in one feature or several. Extending a feature you imported with three new scenarios is a change about those three, so its design doc describes them and not the whole feature. Implementing scenarios that no open change covers — a discovered feature, say — makes a change of its own for the scenarios you selected.
Where the doc goes and what it contains are your repository's call. The design agent reads your
repository's own instructions (its agent instructions files, contribution guide and docs) and follows the
convention it finds: the folder, the file name, the sections, rules such as wireframes for every
screen state. With no convention it uses Repave's template, one file per change in a design folder under
docs — Problem,
What already exists, Proposal, Rejected alternatives, Wireframes, Testing. When it cannot tell, it
asks you on the Design tab instead of guessing. It writes only that one file, and it designs
within the answers you gave in preflight.
Reviewing it:
- While the doc is written, the toolbar reads Writing design doc and the feature gains a Design tab. If the agent asks something, the toolbar reads Answer the agent.
- When it is ready, the toolbar reads Review design and the bell tells you. Open the Design tab and read it.
- Approve and implement approves the doc and starts the implementation — no separate Implement follows. Request changes sends your note to the agent, which revises the same doc; Show changes since approval shows what a revision changed.
The draft stays in Repave until you approve it. The approved doc is committed onto the feature's branch before implementation starts, the implementation agent follows it as its plan, and if the code has to depart from it, the doc is updated in the same commit — the pull request is where you read the final version.
You are asked again only when something real changed. A retry, a resume or a re-run of the same scenarios uses the doc you approved. If the change's scenarios are edited while the doc waits, the tab shows Outdated and offers Update design instead of approval; if they are edited after approval, the next Implement updates the doc first. A doc that could not be written shows the reason and Retry; the features list shows Writing design, Design review or Design failed for a feature waiting on its doc.
With the setting on, Implement All writes every task's design doc when you press Execute, so you can review them in one sitting: the plan's page lists them under Designs, and Review opens each. A task starts as soon as its doc is approved; one still waiting holds up only itself.
With the setting on, implementing a feature yourself in the Repave IDE waits for the same approval: /repave:implement
refuses until the change's design doc is approved on the Design tab. Running Preflight
writes the doc as soon as preflight concludes, and approving it there starts nothing on the
platform — the button reads Approve — so you can implement in the IDE straight after.
Turning the setting off while a change waits on its design doc stops the design agent and hides the Design tab; the doc itself is kept, and is back if you turn the setting on again. A feature whose implementation was waiting for approval goes back to waiting for you to press Implement — nothing starts on its own — while a task of a running Implement All starts straight away. Turning it on applies from the next implementation that starts, including one already waiting for its turn, and to anything you submit from the Repave IDE from then on.
What the agents do
One agent per role does a whole module's work, in one worktree on one branch, one feature at a time: the same agent session picks up each feature in turn, remembering what it built for the ones before, and Repave checks each feature before the next one starts.
The agents commit their own work on the feature branch as they go — after each scenario they
finish and after each fix — so a run that stops keeps everything already built, and the next run
starts from the last commit.
Before the agents start, Repave adds ignore rules for the files a run leaves behind (logs, test
reports, build output) to .gitignore and commits that file on its own, as chore: ignore transient
run files. A scenario you approve while a run is going (an agent's question you answer Yes) is
written to the feature's file and committed the same way, as spec: add "{scenario}", as
approved. When a run finishes, the agent is asked to commit anything it left; a change to a file
already in the repository that it still leaves is committed by Repave, as chore: commit work the
run left uncommitted, and the run's log names it. New files it leaves stay in the feature's
workspace, uncommitted. Nothing a finished run leaves holds the branch from what it builds on, or
from merging.
Along the way:
-
Implementation runs against to-be behaviour only. The legacy code is evidence, not a template.
-
The agents that write the code also lint it.
-
Before handing off, the implementation agent checks nothing the legacy feature does was lost: every field, column, code value, action, validation, message, rule and permission its legacy code paths reach, traced through the specification and into the new database, API and screen. What the implementation lost it fixes, once, and checks again; what the specification itself never described it reports rather than invents.
-
Where a UI prototype was approved for the feature, the implementation reproduces it. In a Storybook project the stories stay in your codebase; the implementation is not held to rendering them again. See UI prototypes.
-
The implementation and UI-check agents verify against a live dev stack — a running application, not a static reading of the source.
-
The UI check sends the implementation back over each difference from the design it finds. After the project's review rounds it is accepted anyway, so that a detail your stack cannot reproduce does not hold the feature forever — and the differences still open are listed under Design in the feature's implementation warnings (see below). They go away when a later implementation of the feature passes the check, for example after Adjust or Revise implementation.
-
Last, once every other check has passed, a code review reads the code for bugs those checks cannot see: a crash, lost data, a double submit, a missing permission check. The implementation agent fixes what it finds, and the Implementation pane says so ("Code review fixed 2 bugs", which opens to the list). A bug still there when the review rounds run out is one of the implementation warnings. For a feature implemented without behavior tests it runs when you write its tests, after they pass.
-
Only you change what a scenario says. When any agent of the run finds a scenario that is wrong — it contradicts what the legacy app does, or another scenario — or behaviour no scenario decides, it does not decide for you. The agent writing the code or the tests, the legacy behaviour review, a validation rule check and the code review all ask the same way: the run waits for your answer, with the scenario shown as it would be written under the question. Yes, add it or Yes, change it puts the scenario in the To-Be, approved, and the same run implements and tests it; any other answer leaves the To-Be as it is, and the code is held to it. You are asked once: no later agent of the run asks about a scenario you have already answered. The implementation agent still fixes a step that is merely broken, such as a typo, without asking. A project that has turned off Agents can ask you and hear from you is never asked, and its scenarios stay as they are.
-
A check that runs out of review rounds leaves a warning. The legacy behaviour review, the UI check, the code review and the database schema check each send the implementation back over what they find, up to the project's review rounds; then the implementation is accepted so the feature is not held forever. When any of them still found something, the feature reads Implemented with warnings, in amber, wherever its status shows, and the feature page has a Warnings tab, with the number of issues still open, listing what each check still found ("5 issues still open when the review rounds ran out"). Click the amber status to open it. The tab is there only while something is open.
- Continue fixing lets the run go on where it stopped: it starts a new implementation at the first check that ran out, gives that check and every check after it a fresh set of review rounds, and does not run the checks before it again. When it finishes, the feature reads Implemented if they all pass, or the tab lists what is still open. While it runs the button reads Continuing…. It is offered on a feature that reads Implemented, or one reopened from it; reopen a merged feature first.
- Mark resolved is for a fix you made yourself in Repave IDE or your own IDE: the feature reads Implemented, and Repave records who resolved them. Repave does not re-check the fix, since it may have been made where Repave can't see it.
Both need the Editor role, and both wait while a run is in progress for the feature, whose result replaces the warnings. A later implementation that leaves checks open shows its own warnings again. A module's page has a Warnings tab too, listing each feature with warnings under its name with its own Mark resolved, and one Continue fixing that continues every one of them in a single module run.
-
A per-run budget stops an implementation before it overspends, rather than after. The fixes, merges and tests that follow have budgets too, set per agent in the project's agent defaults, and an administrator can also limit everything a feature or a project spends. Work a budget stops is kept: reset a run's budget, or raise the feature's, to continue it. See Budgets in the admin portal.
Following it
Develop Features shows what is in flight. Agent Logs shows what an agent actually did, step by step, as a single timeline.
Interrupting an implementation pauses it rather than ending it. You can stop a run, look at where it got to, and resume — and there is one resume path for every way an attempt can stop. A job the platform itself stops resumes by itself.
A module's page
A module's page has five tabs — Features, Gherkin, UI Prototype, Implementation and Preview — and opens on the one where the module's next step is. Each tab's count is its stage's progress, with a spinner while a run of that stage is going and a warning when one needs you. At the top of each stage tab is that stage's action for the whole module: Generate To-Be for the module (and Approve all To-Be scenarios while there are scenarios to approve), Generate prototypes, and on Implementation the next step of the module's pipeline:
- Implement module — or Approve scenarios, which opens the Gherkin tab, when nothing is approved yet;
- Write Tests once its features are Awaiting Write Tests (Run again after a failed run). It opens Write Tests for module, where you choose the features: those awaiting Write Tests are ticked, and a Verified one can be ticked to verify it again — it goes back to Awaiting Write Tests until it passes. Delivered features are listed but cannot be ticked. You can also pick the model and add instructions for the agent, such as permission to rework shared step definitions. Run again opens with the failed run's model and instructions filled in. While it runs, the module reads Verifying on the Modules page and in its header. Each feature's tests and code are reviewed after its tests pass, as for a single feature. UAT itself is started from the UAT page;
- Deliver module, or Open pull request / Refresh pull request when the project merges through pull requests — Open pull requests / Refresh pull requests on a combined workspace.
Below it the tab lists every feature of the module once, with its status, and what the run is doing with it when that adds anything — implementing…, paused here, or why it was not implemented. Beside the list on a wide screen, below it on a narrow one, are the implementation run, the module's verification while it runs or after it failed, and its delivery — what blocks it, its pull request, or where it merged. An action that cannot run yet is shown disabled with the reason under it; one with nothing left to do — its run already going, or the module delivered — is not shown. A project viewer sees each action disabled with "Editing modules needs the Editor role." While a run is going, its own controls — Stop run, Resume, Retry — are the actions.
Above the tabs, on whichever one is open, the module's page says what its branch needs: that the last feature-branch update could not merge the base into it, with Open in Repave IDE on the module's own workspace; that the base has moved on, with Merge <base>, which brings it into the branch every feature of the module shares; and, while a module on one repository is in review, its pull request with the reviewers' open comments and Address N comments, and SonarCloud's quality gate when the project is connected to it. Refresh pull request stays on the Implementation tab. On the Gherkin tab a feature that needs someone says so in the list — paused — needs you, failed or last job failed — and picking it shows, above its Gherkin, its owner, tags, labels and ticket, and the same banners its own page shows, with the same actions, Resume implementation among them.
Build order. A module's features are built one after another, and each one can rely only on what the features before it built. So an agent decides the order: about a minute after a module is created, or after a feature joins it, the Features tab numbers the features in the order they will be built, with a line under each one that depends on another — for example "After Submit a claim: documents are attached to a claim." Every run on the module follows that order — To-Be, prototypes, implementation and UAT — whichever features you pick. Once a feature has its place it keeps it: a feature that joins is placed among the others, and one that leaves is simply taken out. When the agent cannot tell which of two features comes first, it asks you, and the run shows Waiting for you in the running agents; if your project does not let agents ask, it decides itself. Until the order is ready, the actions that build something are disabled with "Working out the build order — this takes a minute or two." If the agent fails, the Features tab says "The build order couldn't be worked out." with Retry; without it, the order is tried again an hour later.
On a combined workspace a module is delivered like any other branch there: Open pull requests
runs the full suite once on the module's branch, then opens one pull request in each source
repository the module changed, and one on the workspace repository for the files outside every
source repository — test steps, scripts — titled with the module and its features. Every feature of
the module moves to review together. The Deliver section lists the pull requests and their state;
merge them on your git server, the workspace one last. Once every one has merged, Repave runs the
full suite on main: when it passes the module is delivered and its features are merged. When it
fails, the section says why and offers Retry, and the features stay in review. A branch someone
else pushed to is never overwritten until you choose Re-split and overwrite and confirm it.
Push and Pull in the module page's header, or in the module's Repave IDE session, move the
module's branches the same way, and
a module whose pull requests are still open cannot be deleted. While they are open, features cannot
join or leave the module; they can again once it is delivered. If a reviewer closes a pull request
without merging and none is left open, the module leaves review: its features go back to completed,
and Open pull requests proposes it again.
Implement module brings over the work your features already have — work done on a feature's own branch before it joined the module, files left uncommitted in its workspace, and commits pushed to its branch from outside Repave — as the run's first step, with no extra click. While it does, the Implementation tab says "Bringing members' work onto module/…" and each feature with work says bringing work over…, resolving conflicts… or work brought over; features with nothing to bring say nothing. Each feature is merged onto the module's branch with a merge commit "Bring {feature} onto {module}'s branch", and its pushed commits with "Bring {feature}'s pushed commits onto {module}'s branch". A feature whose own branch holds only its approved prototype has the prototype copied over as it is, with no merge commit, unless it changes the same lines as work already on the module's branch; then it is merged like any other work. When a merge conflicts, an agent resolves it: it keeps the module's version of files the feature only carried a stale copy of, keeps both sides of shared registrations, and asks you — "Paused — the agent needs your answer.", with Answer — when the two sides set the same thing differently and nothing in the code says which is meant. When the project does not let agents ask, it stops instead of guessing. Then the run goes on to preflight as usual. If a feature cannot be brought over, the run fails with "work not brought over — conflicts in …" on that feature's row; the features already brought over stay on the module's branch, and Retry starts again with the ones left. If the repository cannot be reached to check for pushed commits, the run fails before anything is merged: "Could not reach the repository to check {feature} for commits pushed from outside Repave." Nothing is deleted or pushed: each feature's own branch, and its branch on the repository, stay as they were. A feature's single-feature preflight that finished and is waiting for you to start it is cancelled when the module run starts; a feature still implementing on its own refuses the run, "{feature} has an implementation in progress on its own."
This covers every feature in the module, not only the ones you tick. A feature you leave unticked, or one you cannot tick because it is locked — awaiting Write Tests or completed — has its work brought over in the same way and shows the same line on its row, but it is not implemented again and keeps its status. From then on it works on the module's branch. A feature that is merged, or in review with its pull request open, is left where it is: its work reaches the module through the base branch. A feature you did not tick that is still being implemented on its own refuses the run, "{feature} is being implemented on {module}'s branch. Wait for it to finish before implementing {module}.", and so does one with a job still running on it, such as a UAT bug fix: "{feature} has a job in progress. Wait for it to finish before implementing {module}."
Generate prototypes, and a feature's own Implement or Generate prototype, still refuse a feature whose own branch holds work, for example with "Submit a claim already has work on its own branch feature/submit-a-claim-1a2b3c4d. Merge or reset it before building it as part of Claims intake." The refusal comes with a button — Move work onto Claims intake and build prototypes, or … and implement in a feature's own Implement. It commits what the feature's workspace holds uncommitted, merges the feature's own branch into the module's branch, and does the same for every other feature of the module in that state, then carries on with what you asked for. Nothing is deleted: each feature's own branch stays. If the merge conflicts, the dialog names the conflicting files, moves nothing and offers no button; resolve the conflict by hand or reset the feature. If a run is going on the module, or something is being implemented or built in its workspace, the dialog says so and offers no button; once it has finished, try again.
The page fits the window: the header and tabs stay in place, and only a tab's own list or pane scrolls.
Preview runs the module's branch — every member's code together — in a browser on the page. It starts when an editor opens it, and its Env menu restarts or stops it; before the module has a branch there is nothing to run, and the tab says so. Once the module is delivered and every member has merged, Preview and the UI Prototype tab's stories run the branch the module merged into instead, in the same environment as every merged feature.
AI usage, in the module's ⋯ menu, shows what the module has cost so far, by role and by feature.
Once the module has a branch, the header shows it with the same branch control a feature's page has: the branch name and its state on your git server, the pencil that renames it — see Renaming a branch — and Push, plus Pull on a combined workspace. They act on the branch the module's features share, so a push started here and one started from a feature's page are the same push, and either page shows it running. A viewer sees the branch name only. Once the module is delivered, the control is gone. Changing the module's English name in Rename after the branch exists renames the branch to match.
Checking a scenario against its code
Each To-Be scenario lists the code that implements it under Code on its card, beside the views and APIs it references. An entry is a file and its lines, with a few words on what that code does for the scenario. Click one to read those lines, with the code around them folded and a list of the scenario's other files beside them.
- It is ready when the implementation finishes. Every implementation run, with or without behavior tests, maps the feature's scenarios to its code as it ends. Until that finishes, the card says "Finding the code for this scenario…".
- It shows only code this feature changed. Framework code and code the feature did not touch are never listed. When a scenario is handled entirely by code that already existed, the card says so, and says where.
- It always shows the code as it was mapped. The card names the commit, and the lines you open are that commit's lines.
- It keeps up with later changes. When someone commits to the feature branch after the map was made, the card says "Code changed since … — updating…", keeps the previous map readable, and replaces it when the new one is ready. Nothing needs refreshing.
- If mapping fails, the card says why. An editor can click Try again.
Reading the status
The status vocabulary is precise, and one entry in it is a trap worth knowing:
| Status | What it means |
|---|---|
pending | Discovered, nothing started |
analyzed | The as-is specification exists |
generated | To-be scenarios exist |
in_progress | An implementation is running |
in_review | The implementation finished and is waiting on you |
completed | Implemented on the feature branch — not landed |
merged | On the integration branch, or merged through a pull request |
failed | The run ended without producing an implementation |
partially_implemented | Some scenarios were implemented, others were not |
split | The feature was divided into others |
A completed feature whose checks left something open reads "Implemented with warnings" until
someone marks the warnings resolved; its stored status is still completed.
completed is displayed as "Implemented on Feature Branch" deliberately. The work sits on the
feature's own branch until a merge or a pull request puts it on the integration branch, and reading
completed as "this has landed" is the mistake the wording exists to prevent. merged names the
branch it actually merged into.
A completed feature surfaces its latest job failure whatever the job was, so a feature that looks finished but has a failing job behind it says so.
Building on work that hasn't merged
A feature can build on other work that is still in flight: another feature, a module, or a worktree. Its branch then starts with their work in it, so its prototype, implementation and tests run against their code before it has merged.
- Build on… sits beside the branch on a feature's page, a module's page, and each worktree in Repave IDE. Tick what it builds on and choose Build on selected (or Merge selected in once the branch exists). Add more later with +. A branch can build on any number of others.
- Their new commits come in by themselves. Every commit on what a branch builds on reaches it within seconds, through as many layers as the stack has, even while that work is still being implemented. If the branch has a prototype or implementation of its own running, its agent pauses and commits what it has so far, the commits are merged in on top, and the agent carries on, told what came in; anything it did not commit is kept. The chip reads "Orders · coming in now" meanwhile. A test run or build that is under way finishes first, and a question the agent asked you waits for your answer. A branch nobody is working in takes them at once, even with uncommitted changes: they are set aside and put back after the merge. If its run had stopped, Resume tells the agent what came in. If someone's own changes clash with the new commits, nothing is merged, the chip reads "Orders · conflict to resolve", and the commits come in once the changes are committed or discarded. A branch held by something else takes them once that ends, and its chip says what holds it: "Orders · comes in when the UAT session ends", "Orders · comes in when Repave IDE closes" (uncommitted changes open in Repave IDE), or "Orders · held by an unfinished merge". When the commits overlap with the branch's own changes, an agent resolves the conflict; one it cannot resolve leaves the branch as it was, the chip reads "Orders · conflict to resolve", and the next commit on Orders tries again.
- Picking a feature in a module builds on the whole module, since its features share one branch. The dialog says so. A feature with no branch yet can be picked too: until it has one, the branch takes the integration branch directly.
- What a branch changed leaves out the work it builds on. Code review, the changed-lines check, Compare code and the pull request's description cover only its own changes.
- A branch lands only after the work it builds on has merged. The work it builds on reaches it while that work is still being built, before its own tests pass, so nothing goes to the integration branch ahead of it: Merge to Repave Branch, Create PR and Refresh PR each say "Merge Orders first: Invoices builds on it." until Orders has merged, and then work as usual. A pull request opened before this rule that merges first still lands Orders' work, and Orders is marked merged.
- View stack shows a branch's family: everything it builds on, back to the integration branch, and everything that builds on it. The Stacks tab on the Features page shows every stack in the project, with any conflict first.
- Deleting something others build on is allowed: they keep the changes they already took, as their own. The delete dialog says which branches build on it.
- A branch's agents are told what it builds on, and that that code is not theirs to change. When a test fails because of it, they ask you rather than change it.
Removing what a branch builds on. The × on a chip takes that work away again. Repave rebuilds the branch from the integration branch, or from what it still builds on, replaying only its own commits, and rebuilds everything that builds on it the same way. The dialog names what it rebuilds and which pull requests and remote branches are force-pushed; a pull request keeps its number and reviews. If anyone pushed to one of those branches meanwhile, or a replayed commit conflicts in a way the agent cannot resolve, nothing changes and the page says why. Code that used the removed work may stop building, so run the branch's tests afterwards. The × is disabled while the branch, or anything built on it, has a run going. If none of the removed work ever came in, only the link goes.
Stacking and delivering automatically
With Build on the last one started, and deliver when the tests pass on (Project Settings → Implementation), you do not press Build on… or Create PR yourself:
- A feature's or module's first prototype or implementation builds on the last one started in the project, by anyone, that hasn't merged. Its chip appears as if you had picked it. A branch that already exists, or that you gave something to build on before starting, is left as it is. If the pick is wrong, remove it with ×.
- When its behavior tests pass, Repave delivers it. That is when an implementation with behavior tests completes, or, for one without them, when Write Tests passes. In pull request mode, Repave opens the pull request (or updates the one that is open). With merges to the Repave branch, Repave merges it. Either way only once everything it builds on has merged: until then the page reads "Opens its pull request once Orders has merged." (or "Merges once Orders has merged."), and Repave delivers it by itself when Orders merges.
- If a delivery is refused, for example because the project has no pull request connection, the page says why, and Create PR (or Merge to Repave Branch) is still there once you have fixed it.
Renaming a branch
The pencil on a feature's branch control renames its branch; on a feature in a module it renames the
module's branch, which all its features share, and the dialog says so. The pencil on the module's
own page renames the same branch. You type the part after
feature/ or module/ — that part of the name is fixed — and Repave turns what you type into a
branch name as you type (Create customer becomes feature/create-customer), showing the old and
new names before you confirm.
Renaming moves the branch everywhere Repave holds it: the branch, the worktree and any open Repave IDE session, and — if the branch was pushed — your remote, where the new name is pushed and the old one deleted. Its history keeps the name it had.
- Not while a pull request is open on the branch. The pencil is disabled and says "Can't rename while pull request #42 is open. Close it to rename the branch." Close the pull request, rename, and the next pull request is opened from the new name.
- Not while work is running on it — an implementation, a push or pull, tests. The reason is shown on the disabled pencil.
- Not after it is merged; the pencil is gone.
- A name another branch has, or one a branch was renamed away from, is refused.
- If your remote refuses — an expired token, a branch policy — the rename still stands in Repave, and the branch control shows Remote not renamed with Retry. Pushing the branch from the feature page finishes it too.
- A computer still on the old name is told where the branch went the next time it runs
repave pushorrepave pull, with the two git commands that follow the rename. If someone pushes the old name to the remote again anyway, the branch control says so and offers Delete it, after asking — that push may hold work that is nowhere else. - CI triggers, branch policies or links on your side that name the old branch are not changed.
Getting it onto the integration branch
Two merge modes, set per project:
- DIRECT — the feature branch merges into the project's integration branch,
repaveby default. - PR mode — a pull request is opened against your own base branch, and the Pull Requests view
tracks every one Repave opened through to a verified landing. Your Git provider shows every one as
opened by the account whose token Repave uses, so each row in the view names the person who opened
it: whoever clicked Create PR or started the job, and nobody for one Repave opened on its own.
The view's search matches that name too.
A module's pull request is one row, named for the module and linking to its page; searching for
one of its features finds it, and its Refresh PR refreshes the module's pull request. The
Repave column says what Repave is doing on each open pull request — Fixing 2 failed checks,
Addressing comments, Refreshing the pull request — or what it is waiting for: 3 comments to
address, Waiting for your answer, Waiting for review. Click it to see the pull request as its
feature or module page shows it: whether it still holds against your base branch, its checks,
SonarCloud and its review comments, with the same one action.
An agent, the Pull request writer, reads the change and writes each pull request's title and
description: what the change does, the files it touches, how it was validated, and the issue it
closes. The title carries the feature's Jira key or GitHub issue in front, as in
feat(SOP-117): Add the application wizard. Refresh PR rewrites them only when the code, or what was validated, has changed. If the writer cannot finish, nothing is opened or updated and the job says why; press Create PR (or Refresh PR) again. Its model and timeout are in Settings → Agent Defaults. A finished feature spanning several source repositories becomes one pull request per repository. On a project that combines several repositories, the files outside every repository (test harness, step definitions, scripts) get a pull request of their own on the combined repository, listed as workspace: merge it after the others, because nothing else puts those files on the base. A feature already in review without one has it opened by Repave the next time it checks the pull requests. Once every pull request has merged, Repave runs the feature's scenarios on the merged combination and marks the feature merged when they pass; when they fail, the group says why and offers Retry. If the full suite fails before a pull request is opened or updated, Repave fixes the feature and sends the fix to that same pull request; nothing reaches your base branch except through review. A fix to a feature whose pull request has already merged is refused before it starts: reopen the feature or start a new one. If the merged combination cannot be synced to verify it, the pull request group shows the reason and a Retry button instead of a verification that never finishes.
A GitHub issue for every change
In PR mode on GitHub, Repave opens a GitHub issue for every change it builds: the moment you press Write scenarios in Add feature, and when you implement scenarios that no open change covers. It is opened with the project's GitHub token, so GitHub shows the token's owner as its author. A repository with Issues turned off gets none, and a project whose issue tracker is Jira gets a Jira ticket per feature instead (see Issue tracker). A project can also choose no issue tracker, and get no issues at all.
The issue says only what the change's pull request will publish anyway: the change's title, the names of the scenarios it adds or edits, its pull requests, and a status that follows the change from Writing scenarios through Design review and In review to Merged. It never carries what you typed in Add feature, the names of the documents you uploaded, or who asked for the change. Repave keeps the text between its markers current and never touches what you write outside them; delete the markers and it stops updating the body. If your request names one issue of the repository by its URL, Repave uses that issue instead of opening another, and the agent writing the scenarios reads it.
A change shipped as one pull request says Fixes #N, so GitHub links the two. A change that ships as
several pull requests, or across the repositories of a combined project, says Refs #N on each.
Either way, Repave closes the issue when the whole change has merged, with a comment naming the pull
requests, even when they target a branch other than your default branch. A change that is dropped
closes its issue as not planned; an issue you named in the request gets a comment and stays open.
Repave never reopens an issue, and leaves one a person closed or reopened as they left it.
The feature page shows the issue beside the feature's branch. If the token cannot open issues, it shows No GitHub issue with the reason: give the token Issues: Read and write (a classic token needs the repo scope) in Settings → Integrations, and the issue opens on its own within ten minutes.
Review comments on a pull request
In PR mode Repave reads the comments reviewers leave on its pull requests, on GitHub, Azure DevOps, Team Foundation Server, GitLab and Gitea, about every ten minutes and whenever the feature is opened. The feature's Pull Request panel lists the open ones, each with who wrote it and where, and the Pull Requests view counts them per pull request. On a project that combines several repositories, the comments on every pull request of the feature's group are listed together.
While a comment is open, the panel's Refresh PR becomes Address N comments. It asks for optional instructions ("Keep the existing column names; the naming comment is out of scope"), then an agent works through every open comment: it changes the code where a reviewer asked for a change (updating the feature's scenarios first when the change alters what the feature does), answers questions, and declines with a reason a change it should not make. The pull request is then updated as Refresh PR updates it, with the base merged in and the full test suite run unless the project skips it, and only once the change is on the pull request does Repave reply on each comment: "Changed: …", "Answered: …" or "Not changed: …". A comment with nothing to answer, such as "LGTM", gets no reply. A change Repave's own review could not confirm gets no reply either and stays open, marked Not confirmed. Repave never resolves, closes or merges anything on the provider.
A reviewer who answers one of Repave's replies opens the comment again. Replies are posted as the token owner, and Repave recognises its own by the reply it posted, so a reviewer who owns the token is still read as a reviewer.
Developers working in Repave IDE or their own IDE answer comments with /repave:review-comments
instead; see Repave commands.
Checks on a pull request
In PR mode Repave also reads every check your CI reports on its pull requests, on GitHub, Azure DevOps and Team Foundation Server: GitHub Actions jobs, other apps' check runs and commit statuses, and Azure DevOps build validation and status policies. While CI is still running on a pull request, it reads them every minute, so a fix starts within about a minute of the last check finishing. Once every check has finished, it reads them about every ten minutes and whenever the feature is opened. Every check counts, whether or not the branch's protection rules require it. The feature's Pull Request panel, and a module's, shows a Checks line:
- 2 of 4 running on 9c69774 while CI runs on the commit Repave pushed.
- 4 checks passed.
- 1 failed · fixing, with each failed check linked to its run, while Repave fixes it. The button reads Fixing checks… meanwhile.
Repave fixes a failed check by itself. Once every check on the commit has finished, an agent is sent what failed: the failures the check located (file, line and message), then the error lines of its log. It runs the failing command, fixes the code (or a test that is wrong about the feature), and the pull request is updated as Refresh PR updates it. CI then runs on the new push, and Repave reads it again, until nothing fails. When SonarCloud is connected, the same run also fixes what SonarCloud's quality gate found (see SonarCloud).
- Repave never skips or weakens a test, and never changes your CI configuration, to make a check pass.
- Repave fixes every failure on the pull request, whichever feature's code or test it is in, and reproduces it with the job's own command, run the way your CI runs it. A job that ran past its time limit is fixed like any other failed check: the agent reads why it stopped from what your provider reported, and finds what made it slow. Raising the time limit is never the fix. A run someone cancelled goes to the agent too, which asks you before it leaves it, as below.
- For each check it fixed, the agent reports the command it ran to show the check passes and how that ended. A reviewing agent passes the fix only when that is the job's own command, run as your CI runs it.
- Repave asks before it leaves a check unfixed. A failure the branch did not cause, such as a CI runner that ran out of disk or a service the job needed being down, the agent asks you about in its conversation, with its reason: Fix it or Leave it. While it waits, the line reads 1 failed · waiting for your answer, and those words open the question. Fix it has it fixed in the same run. Leave it leaves the check: the line reads 1 failed · left as decided, with the reason and Left by your name under the check. Rerun the job in your CI: a run that passes clears it, and a run that fails again sends the check back to Repave to fix. Repave also tries again after the next push. When Agents can ask you and hear from you is off for the project, the agent declines such a failure itself, with its reason: 1 failed · Repave declined the fix.
- A job that fails only because it waits for SonarCloud's quality gate (a SonarScanner step) reads fails with SonarCloud's quality gate, and the line waits on SonarCloud: fixing what SonarCloud found clears it, so it is not fixed twice.
- If its fix failed twice on the same push, the line reads Repave's fix failed, and it waits for the next push. Press Fix again beside it to start another run now. Its dialog takes an optional instruction for the agent, such as how to reproduce a failure that only shows in CI. Each run counts against the project's agent budget.
- What only a person can clear is listed and starts nothing: Waiting for approval, Changes requested by a reviewer (see Review comments), a check waiting for someone in your provider, such as a deployment approval, and Conflicts with main, which the automatic feature-branch update resolves (on a worktree's pull request, Repave resolves it itself: see Repave IDE).
Reading checks needs a token that may read them. A classic GitHub token's repo scope covers it. A fine-grained token also needs Checks: read, Commit statuses: read and Actions: read. An Azure DevOps token also needs Build (read). Without them the line says what to grant, with Try again.
Checks are read for single-repository projects. GitLab and Gitea pull requests show no Checks line.
The same goes for the pull requests Repave opens that no feature owns. In the Pull Requests view, click a row's line in the Repave column, such as 2 comments to address, to see its review comments: what each reviewer said, and what to do about it.
- Repave's own pull requests, such as the UAT harness configuration or the catch-up of the integration branch, get Address N comments. Repave changes that pull request's branch as the pull request holds it, pushes it, and replies on each comment. No test suite runs, as none runs when Repave opens such a pull request. If Repave regenerates that pull request later, it starts again from your base branch and does not keep these changes. If it regenerates it while the comments are being addressed, nothing is pushed or replied and the comments stay open.
- A worktree's pull request, opened from Repave IDE's Worktrees list, gets Address N comments
too: click the comment count on the worktree's row. Repave changes the code in your worktree,
leaves your uncommitted edits as they are, pushes only its commit, and replies on each comment. You
can still answer them yourself with
/repave:review-commentsin that worktree; those replies are posted when you next push it.
To stop reading comments for a project, clear Read review comments on pull requests under Merge mode on the Integrations tab of Project Settings. It is on by default.
Each of these automatic test runs, before work lands, after it lands, and when an agent resolves a merge conflict, is chosen per project under Test runs in Project Settings. A new project leaves all three out; untick an option there to have that run happen. A pull request opened without a test run says so in its description and on the feature page.
In either mode the base branch can be merged into a feature branch when it has moved on, a conflicted merge leaves the checkout clean rather than half-applied, and a failed merge job does not mark the feature itself as failed. Several completed features can be tested together before merging, and once a feature's pull requests have all merged, the combination that landed is verified.
When an agent resolves a merge conflict, it runs the full test suite itself. Repave keeps the resolution only when that run's report shows every scenario passing, covers every scenario in the suite, and was written after the agent's last change; otherwise the agent is asked to fix it. If it cannot within its attempts, the branch is put back exactly where it was, even when the agent had already committed the merge. An accepted run is not repeated before the pull request is opened, but unit tests still run. After a pull request group merges, Repave does not test the merged code again when it is identical to the code that already passed before the pull requests were updated.
Reopening finished work
Completed and merged features require an explicit reopen before further edits. This is a guard, not an obstacle: it stops an accidental edit to a feature someone has already shipped.
A feature reopened from Awaiting Write Tests or Completed keeps its implementation, so Adjust, Revise implementation and the Stories segment's Write stories and Update stories still work on it, and it stays reopened afterwards. A feature reopened after it merged is changed by implementing it again.
Closing a reopened merged feature again, while nothing has changed, also takes away the working copy its preview or Repave IDE recreated, unless that copy holds work the merged branch does not have or someone has it open in Repave IDE; then it is kept.
Resetting a feature stops its preview and any Repave IDE session on it and removes its working copy. If the working copy cannot be removed, the reset stops and says why, and the feature is left as it was.
Next: Repave IDE.