Skip to main content
Version: 0.1.145

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:

  1. 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.
  2. When it is ready, the toolbar reads Review design and the bell tells you. Open the Design tab and read it.
  3. 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​

The work is batched by the Rule: blocks in your Gherkin, so the boundaries are ones you wrote and reviewed rather than ones a model invented. 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 and commits each feature before the next one starts — so a run that stops keeps every feature already finished.

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. When the review finds a scenario that is wrong, or behaviour no scenario decides, it does not decide for you: it asks, and the run waits for your answer, with the scenario shown under the question. Yes, add it or Yes, change it puts the scenario in the To-Be, approved, and the same run implements it; any other answer leaves the To-Be as it is. A project that has turned off Agents can ask you and hear from you gets the bug review only. For a feature implemented without behavior tests it runs when you write its tests, after they pass, and asks the same questions; a Yes is written and tested in that run.

  • 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 and verify the module once its features await UAT (Run again after a failed verification). 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 — waiting for UAT 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:

StatusWhat it means
pendingDiscovered, nothing started
analyzedThe as-is specification exists
generatedTo-be scenarios exist
in_progressAn implementation is running
in_reviewThe implementation finished and is waiting on you
completedImplemented on the feature branch — not landed
mergedOn the integration branch, or merged through a pull request
failedThe run ended without producing an implementation
partially_implementedSome scenarios were implemented, others were not
splitThe 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.

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 push or repave 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, repave by 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. 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.

The same goes for the pull requests Repave opens that no feature owns. In the Pull Requests view, click a row's comment count to open 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, is answered from that worktree: run /repave:review-comments there, and the replies are posted when you next push it. The Worktrees list shows a count on the worktree when it has open comments.

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 UAT 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.