Skip to main content
Version: 0.1.147

Project settings

Settings are per project. This page covers what a project owner changes in the normal course of work; the deployment-level configuration behind them — registries, gateways, credentials on the host — belongs to whoever installed the platform, and is covered in Install with Docker Compose.

Controls only an owner can use say so, rather than failing when you click them.

How work lands: merge mode​

The single most consequential setting.

  • DIRECT — feature branches merge into the project's integration branch. A merge runs every scenario in the project twice: on the feature branch before it merges, and on the integration branch after. Skip the second full test run when nothing changed, under Direct, skips the second run when the merged code is exactly the code that just passed. Anything that changes the code in between, such as new commits on the integration branch, still runs the full suite. Off by default.
  • PR mode — feature branches become pull requests against your own base branch, tracked in the Pull Requests view. Repave never writes to your base branch itself. Configuration it generates — BDD and UAT test configuration, preview dev configuration, sample data seeds and the design system — arrives as a pull request of its own, from a repave-platform/ branch, and the job says which one it opened. In direct mode the preview dev configuration is committed to your integration branch, so every new feature branch starts with it. A feature's BDD run needs the BDD configuration, so until that pull request has merged the run does not start, and says which pull request to merge.

An existing project can be migrated from DIRECT to PR mode. A feature merged before the switch says which branch it merged into, such as Merged to repave branch, until Repave finds its work on your base branch. From then on it reads Merged to main branch (or whichever base branch you set). Repave checks this itself, even for features whose branch was deleted when they merged. A feature whose work has not reached your base branch keeps naming the branch it merged into, and its page says the work is still to land.

Test runs​

Repave can run the project's full test suite automatically around landing work, so a broken feature never reaches your base branch untested. Three options under Test runs, in the Merge mode section, leave those runs out. Each applies in both merge modes. All three are on for a new project, so it lands work without waiting for the suite; untick one to have that run happen. A project created before they became the default keeps the choices it had:

  • Skip the full test suite before work lands. Before a pull request opens, or a Direct merge goes in, Repave merges the base branch in and runs every scenario and the unit tests against the result. With this on, the pull request opens, or the merge goes in, without that run. Create PR, Refresh PR and repave pr create all follow it, and the merge and pull request dialogs say so before you confirm.
  • Skip the test run after work lands. After a Direct merge, Repave runs every scenario again on the integration branch. On a project with source repositories, once a feature's pull requests have all merged, it runs the feature's scenarios on the merged combination before marking the feature merged. With this on, neither run happens. A project with a single repository in pull request mode runs nothing after merge, so it is not offered this option. While it is on, Skip the second full test run when nothing changed is hidden, because there is no second run to skip.
  • Resolve merge conflicts without running the full test suite. When a merge conflicts, an agent resolves it and then runs every scenario, fixing failures until they pass. With this on, the agent resolves the conflict and stops there. This covers every merge an agent resolves: Create PR, Merge from, Update feature branches, Pull and a Direct merge.

What was skipped stays on record. A pull request opened without a test run says so in its description, and the feature page and the pull request group say so too, even after the option is turned off again. A pull request opened without a test run is still tested after it merges, unless Skip the test run after work lands is on as well.

Implementation gates​

What has to be true before an implementation is accepted. Each is a switch, and together they decide how much the platform insists on before it calls a feature done:

  • unit tests, and a coverage threshold — the minimum line coverage both for the lines a feature changes and for the whole project. A change with fewer than 20 coverable lines is judged on the whole project only
  • a false-positive review of passing unit tests — off by default, and worth turning on where green tests are not trusted
  • UI, API and database-schema checks
  • scenario-drift detection
  • a maximum number of review cycles
  • Write a design doc before implementation — off by default. On, every change waits for a design doc you approve before it is implemented; see Implementing a feature
  • Build on the last one started, and deliver when the tests pass — off by default. On, each feature's or module's first prototype or implementation builds on the last one started, and passing behavior tests open its pull request (or merge it into the Repave branch once what it builds on has merged); see Implementing a feature

Numeric settings are bounded, so a value that would make no sense is refused at the point you set it.

Models and agents​

Agent Defaults is a table with one row per agent the product runs. Per agent you can set:

  • the model it runs with, and the advisor model that reviews its work
  • its timeout
  • how long its prompt cache lives, and what that has cost
  • whether it gets a browser
  • what memory it captures, uses and is given
  • its budget: the most one run of that agent may spend. Empty means no limit of its own. It cannot be more than the maximum per run your administrator sets, and it is read-only when your administrator does not let users set budgets (see Budgets).

To set one of the on/off columns (Browser, Graph, Capture, Tools, Inject) for every agent at once, use the checkbox in that column's heading. It ticks every agent, or clears every agent when they are all ticked, and shows a dash when they disagree. Agents that are switched off elsewhere in settings are left as they are, and Inject is only ticked for agents that have Tools.

There is no setting for the legacy app: every agent can start it when it needs to (see Other agents can use the legacy app).

A per-run model an operator picks for one launch overrides the row for that run only.

An agent's model is one of three Claude tiers, and Elite model name, Pro model name and Speed model name say which model each tier runs. A new project starts on Claude Opus 5.5, Claude Sonnet 5.5 and Claude Haiku 5.5; an existing project keeps the models it has until you change them. Claude Haiku 5.5 costs five times as much per token for a turn whose prompt is over 100,000 tokens, cached tokens included, so a Speed agent that reads a lot uses up its budget faster than its short turns suggest.

Changing an agent's model, or which advisor the project uses, turns off any advisor that can no longer advise that agent. When you change the advisor, the page also tells you how many agents it turned off. If you undo the change before you save, those advisors come back. An advisor you picked yourself in the meantime is kept.

Agents can ask you and hear from you, under the table, is on by default: every agent can ask you questions, wait for your approval of commands its safety check hands back, and read what you type in its chat (see Talking to an agent while it runs). Turn it off and agents run without stopping, as before. The change applies to runs started after you save.

Run the pipeline with AI-DLC, inside that box, is off by default and offered on web application projects. Tick it and save to run requests through AWS AI-DLC's own stages: on the Features page, From Requirements becomes Start with AI-DLC, and the run asks you at every stage, in its chat, before it moves on (see Runs started with AI-DLC). It needs Agents can ask you and hear from you: while that is off the box is disabled and says why, and saving that off turns AI-DLC off too. Turning it off later changes nothing the runs already wrote.

Always-allowed commands, below it, lists the commands someone chose Always allow for when an agent asked, with who added each and when. The agent runs those without asking. Remove takes a command off the list for the next run, after which the agent asks again.

Project assistant, a box of its own below that, is off by default. Tick Turn on the project assistant and save to give the project the assistant: a chat beside every project page, opened from the Assistant button in the header (see Project assistant).

Providers​

How agent calls reach a model. A new project defaults to direct dispatch; the routed modes are available where your deployment enables them:

  • Anthropic API directly
  • Vertex AI, running Claude models in your own GCP project
  • Gemini, and other providers, through the translation gateway

An agent on a Gemini or Codex model works with as much context as that model accepts and compacts its conversation only as it nears that limit. A model Repave does not yet know the limit of — one you mapped a tier to after it shipped — is treated as having 200K tokens, and the job log names it. Its agents compact at 200K, so a model that accepts more is not fully used, and one that accepts less than 200K can still be sent more than it allows. Longer context also means each turn sends more tokens, so a long run on a large-window model costs more per turn than it did when it compacted sooner.

A project with no key of its own uses the one your administrator set in the Admin portal; its field reads Using organization key. Enter a key here to use a different one for this project.

Provider and memory smoke tests are on this page: run them after changing anything here rather than finding out on your next implementation.

Integrations​

  • GitHub / Azure DevOps — a personal access token and branch pushes, and for GitHub, creating a repository for the project. The link maintains itself: it pushes on creation, syncs both ways, and pushes again at merge time. In pull-request mode Repave also reads the checks on its pull requests and fixes what fails: a fine-grained GitHub token needs Checks: read, Commit statuses: read and Actions: read, and an Azure DevOps token Build (read). See Checks on a pull request.
  • Team Foundation Server — including trusting a private certificate authority, or skipping TLS verification for one connection.
  • GitLab — gitlab.com or a self-managed GitLab. In pull-request mode, features open merge requests on GitLab. A project on a self-managed GitLab shows the Git connection card, where TLS verification can be skipped for that connection, as for Team Foundation Server; a gitlab.com project's card has no certificate options, because gitlab.com's certificate is public.
  • Gitea — a self-hosted Gitea or Forgejo. In pull-request mode, features open pull requests on Gitea, and Repave answers review comments in the conversation they were left in. Every Gitea project shows the Git connection card, where TLS verification can be skipped for that connection, as for Team Foundation Server.
  • Git connection — the project's own personal access token, named by what it reaches, with Replace token to renew it when it expires; the new token must belong to the same account.
  • Issue tracker — GitHub Issues, Jira, or none. See Issue tracker below.
  • SonarCloud — in pull-request mode, Repave reads SonarCloud's quality gate on each pull request it opens and fixes what fails. See SonarCloud below.
  • Source repositories — for a project combining several, managed here.
  • Package registries — where agent jobs, test containers and scaffolding resolve dependencies from. Set these for an air-gapped or proxied network.
  • Prototypes — Prototype Mode, where each feature's prototype comes from: HTML, Figma, or Storybook (the project's own components, with a story per To-Be state), and whether HTML and Figma designs are also built on your own stack. While they are, Check target-stack builds against their design sits under that choice: the project's default for comparing each build of a feature, and the application shell's implementation, with its design. The build dialog can change it for one build. With designs not built on your own stack the check does not run. Choosing Storybook sets it up in your codebase straight away and shows how that is going on this card. A Storybook project also shows the Figma connection, under Figma (optional), so a single feature can be designed in Figma instead of as stories. See UI prototypes.

SonarCloud​

Settings → Integrations → SonarCloud connects a pull-request-mode project to the SonarCloud project that analyses its repository. The card is shown only in pull-request mode, because SonarCloud analyses pull requests.

FieldWhat to enter
Project keyThe SonarCloud project's key, such as acme_claims-portal (SonarCloud → the project → Information).
TokenA SonarCloud token with Browse permission on that project: a user token, or a scoped organization token.

On a combined workspace, each source repository is its own SonarCloud project, so the card has a Project key field for each repository, and one token for all of them. Leave a repository's key empty to skip it: its pull requests show no SonarCloud line. The token needs Browse permission on every project you name.

Save Changes checks both with SonarCloud before anything is saved. If SonarCloud refuses them, the reason shows under the field it concerns: "SonarCloud rejected this token.", or "This token cannot see a SonarCloud project with this key." If SonarCloud does not answer, the card shows "Could not reach SonarCloud: …"; on an air-gapped installation, SonarCloud cannot be used. The token is stored encrypted, sent only to SonarCloud, and never shown again: the card shows Token saved with Replace token. Disconnect and Save Changes remove the connection.

Once connected, there is nothing else to set:

  • Each feature's pull request panel shows a SonarCloud line: Analysing while SonarCloud analyses the latest push, Quality gate passed, or Quality gate failed with each failed condition, such as "Coverage on new code 38.1% (needs ≥ 80%)". SonarCloud links to the pull request in SonarCloud.
  • When the gate fails, Repave fixes it by itself: an agent fixes the issues that fail the gate (the bugs for a reliability rating, the vulnerabilities for a security rating, the code smells for a maintainability rating), writes unit tests for new lines left uncovered, removes duplicated code from the files SonarCloud names (each repeated block, and where it repeats), and changes the code a security hotspot points at when it is a real risk. Then the pull request is updated as Refresh PR updates it, with the full test suite run first. The button reads Fixing checks… meanwhile: the same run fixes any failed check on the pull request too (see Checks on a pull request). SonarCloud analyses the new push, and Repave reads it again.
  • Repave never weakens a test or excludes code from analysis to pass the gate.
  • Repave asks before it leaves a finding unfixed. A finding the agent judges a false positive, or one whose fix would break something the codebase does on purpose, it asks you about in its conversation, with its reason: Fix it or Leave it. While it waits, the line reads Quality gate failed · waiting for your answer, and those words open the question. Fix it has it fixed in the same run. Leave it leaves the finding, and it is never sent to an agent again; the panel lists it under Left, with the reason and Left by your name. Mark it in SonarCloud (for example, accept it) so the gate no longer counts it. When Agents can ask you and hear from you is off for the project, the agent declines such a finding itself, with its reason.
  • Repave keeps fixing each new push until the gate passes. It stops when every finding left was left or declined, or when its fix failed twice on the same push; the panel says so (left as decided, or Repave declined every finding) and lists those findings with their reasons. Fix the rest in Repave IDE or your own IDE, or resolve the findings in SonarCloud; your next push is read the same way, and Repave fixes what is still failing. Each round counts against the project's agent budget.
  • Security hotspots are sent to the agent like any other finding: it fixes the code where a hotspot is a real risk, and asks you about the ones it judges safe. Marking a safe hotspot reviewed is still done in SonarCloud, and the panel links to the hotspots to review. A condition Repave does not recognise is sent to the agent as the condition, with SonarCloud's value and threshold.

SonarCloud is read for single-repository projects. Self-hosted SonarQube is not supported yet.

Issue tracker​

Settings → Integrations → Issue tracker chooses where Repave records the work it does.

  • GitHub Issues is the default. In pull-request mode on GitHub, Repave opens a GitHub issue for each change and closes it when the change merges (see A GitHub issue for every change). Other projects get no issues.
  • Jira links each feature to a Jira ticket. Repave adds a comment to the ticket as the feature moves, and puts the ticket's key in the feature's branch name, commit messages and pull request title. A Jira project gets no GitHub issues; issues Repave already opened are left as they are.
  • None records nothing outside Repave: no GitHub issues and no Jira tickets or comments. Issues Repave already opened are left as they are, and the feature page no longer shows them.

Switching away from Jira stops the comments and hides the Jira controls. Each feature keeps its key, so switching to Jira again restores the links.

Connecting Jira​

Choose Jira and fill in:

FieldWhat to enter
Jira siteYour Jira's address, such as https://your-company.atlassian.net, or a Jira Data Center address.
EmailJira Cloud only: the email of the account Repave acts as.
API tokenJira Cloud: create one at id.atlassian.com → Security → API tokens. For a Data Center site the field reads Personal access token: create one in Jira → Profile → Personal Access Tokens.
Project for new ticketsThe key of the Jira project Create ticket creates tickets in, such as CLM. Linking accepts a ticket from any project the account can see.
Issue typeThe type of the tickets Repave creates. Task unless you change it.

Save Changes checks the connection with Jira before anything is saved. If Jira refuses it, the reason shows under the field it concerns: a rejected token, a project the account cannot see, or an issue type the project does not have (with the types it does have). A site that does not answer shows "Couldn't reach …"; on an air-gapped installation, Jira cannot be used. The token is stored encrypted, sent only to your Jira, and never shown again: the card shows Token saved with Replace token.

Use an account that can see the projects your tickets are in, add comments, and create tickets in the project for new tickets.

Linking a feature to its ticket​

Each feature page shows a Jira ticket button in its header. Type the key, such as CLM-117, and press Link: Repave asks Jira whether the ticket exists, and stores the key only when it does, so a typo never sends comments to someone else's ticket. A feature with no ticket yet can use Create ticket in CLM instead: Repave creates one titled after the feature, with the feature's description and a link back to it in Repave. Once linked, the header shows the key, which opens the ticket in Jira; the pencil beside it changes the ticket or unlinks it. Viewers see the key only.

To link many features at once, for example from a mapping you already keep, use repave features jira import (see Repave CLI). repave features list --jira none lists the features that still have no ticket.

What Repave tells the ticket​

Repave adds one comment for each of these, and never edits a comment, moves the ticket's status or changes any other field:

WhenComment
To-Be scenarios are approvedRepave: Alex Kim approved 3 To-Be scenarios: Attach a photo; Remove a photo; Refuse an oversized photo.
The design is approvedRepave: Alex Kim approved the design.
An implementation run finishesRepave: implemented on branch feature/CLM-117-claim-photos-4def5ghi (started by Sam Lee). A run without behavior tests adds , awaiting Write Tests.
A pull request is openedRepave: pull request opened: <link>.
The feature is mergedRepave: merged to main in <link>., or, when someone marks it merged, Repave: Sam Lee marked it as merged.

Each comment ends with a link to the feature in Repave. Comments are posted within about a minute, in the order the events happened. Nothing in Repave waits for Jira: if Jira is down, approvals, implementation and merges carry on, and the comments follow when Jira answers again, never twice.

If comments cannot be posted, the key in the feature header turns amber; click it for the reason. A rejected token is fixed by saving a new one in Settings → Integrations, a missing permission in Jira, and a ticket that no longer exists by linking the feature to another. The waiting comments are then posted on their own. An outage shows only after an hour.

The key in branches, commits and pull requests​

A feature linked to a ticket gets the key in:

  • its branch name, when the branch is created after the key is set: feature/CLM-117-claim-photos-4def5ghi. An existing branch keeps its name; Rename branch moves it.
  • its commit messages: feat(CLM-117): …. Repave adds the prefix itself if the commit does not start with it.
  • its pull request title: feat(CLM-117): Claim photos. A module's pull request names every member's key: feat(CLM-117, CLM-118): Claims.

Features with no key get none of these, and Repave never makes one up.

The code index​

Two checkboxes decide whether the code index runs. The page reports what state the index is in and lets you rebuild it. It is what lets agents answer questions about the codebase without reading all of it, so a stale or missing index shows up as agents that seem not to know their way around.

The index reads the codebase's documents as well as its code — READMEs, design notes, specifications and similar files — so agents can find what a part of the code is for, not only how it is wired. Images and video are never read. Documents are read by the model set for Graph index in Agent Defaults, with the same credentials as the project's other agents, and what that costs appears on the Costs page with the rest of the index build.

When no model can be reached — no credentials are set up, the model cannot be contacted (as on an air-gapped install), or it answers with an error — the index is still built, from the code alone, and its card says so and why: for example, "Built from code only. Documents were not read because no model credentials are set up for this project's agents." If only some documents could not be read, the card says that instead. Re-index tries again, and reads only what it has not read yet.

The modernized index keeps up with each commit without calling a model, so a document changed since the last full build keeps what was read from it before, and the card says "Documents have changed since they were read." Re-index reads them again.

Every worktree Repave or an agent works in has its own copy of the modernized index from the moment it is created, and that copy follows the worktree's commits — whoever makes them, an agent, the platform or you in the Repave IDE. Repave checks every worktree against its latest commit about once a minute, so an index usually catches up with its code within a minute; one whose last update failed is retried an hour later. Keeping a worktree's index current never calls a model. A full build of the modernized index that fails is not retried until you click Try again, because each build calls a model.

In pull-request mode the modernized index follows the branch your pull requests merge into, rather than Repave's own working copy, catching up each time Repave next fetches that branch.

Daily tests​

The Daily tests card on the Implementation tab runs the project's whole BDD suite once a day, and decides whether a failed run fixes itself; see Daily tests for what each run does. Run the full test suite daily is off by default. Turn it on and the suite runs at 02:00, or at the time you choose, read in the time zone beside it — the server's by default, or one you pick — exactly as the Repave IDE daily stop below reads its time.

Fix failures automatically is off by default too, because a fix starts an agent. Off, a failed run only reports, and Fix failures on the run's page starts the fix when you choose. On, a failed run starts the fix agent by itself. It applies to every run, scheduled or started with Run now, so it can be on while daily runs are off. Neither switch can be turned on until the project has a BDD test script, set under General.

Parallel workers is how many scenarios a run runs at once, for scheduled runs and Run now alike. It is 1 by default, one scenario at a time, and goes up to 32. Each extra worker starts its own copy of the app, its own database and its own browser, so scenarios running side by side never share data. That only works if the project's BDD test runner supports it: Repave's own runner does, and /repave:bdd-parallel adds it to a runner of your own. A runner that does not support it runs one scenario at a time, whatever the setting says.

A daily run has its own memory limit, Daily test run under Container resources on the General tab: 16 GiB by default, for the container that runs the suite and for its Docker sandbox alike. It replaces Test containers and Docker sandbox for that run only, so a larger suite can be given room without raising the limit for every feature's tests and every agent. Raise it with the number of workers.

Your repository can ask for more for its own checks. When a script in its package.json sets a Node heap with --max-old-space-size, the containers that run the project's checks — the agent's, the test containers and the daily run's suite container — get at least that heap plus 4 GiB, whatever the fields above say. A script running node --max-old-space-size=8192 … gives them at least 12 GiB. The fields still show your setting, and a larger setting is kept; the raise stops at the host's memory less what Repave keeps for itself. The memory meters on the Queue show the limit a container actually got. Repave never sets a Node heap itself: the script that needs one says so.

Repave IDE​

The Repave IDE card on the General tab sets when the project's sessions are stopped each day. Stop all Repave IDE sessions daily is off by default, so sessions stay open until someone stops them. Turn it on and every session of the project is stopped at 06:00, or at the time you choose. The time is read in the time zone chosen beside it. By default that is the server's, shown as for example Server time zone — Asia/Singapore (UTC+08:00); pick another zone from the list to read the time in your team's own, for example America/Los_Angeles (UTC-07:00). Daylight saving is followed automatically. The stop runs only when the clock passes the time, so saving a time that has already passed today stops nothing until tomorrow, and a time the server was down for is not made up later.

Earlier versions had the stop on by default. Upgrading turns it off in every project, including one where it had been chosen; the time is kept, so turning the switch back on restores it.

If the card says the server's time zone is not recognised, the REPAVE_HOST_TIMEZONE value in the server's .env is not a valid time zone name. A project that follows the server's time zone stops no sessions until you choose a time zone for the project, or fix the value and restart Repave. If it says this project's time zone is no longer recognised, the server no longer knows the zone the project chose (this can follow an upgrade); the project stops no sessions until you choose another.

The same card holds two boxes for what every session of the project is given:

  • Mounted files — one per line, a path on the server, a colon, then the path in the IDE, for example /srv/shared/db-image:/data/db-image. The file or folder appears at the IDE path in every session, read-only, and in the session's own Docker daemon at the same path, so a docker compose file run in the session can use it too.
  • Environment variables — one per line, NAME=value, for example BDD_PARALLEL_WORKERS=2. The value is everything after the first =, taken as written: quotes are not removed and trailing spaces are kept.

Blank lines and lines starting with # are ignored in both. A line that cannot work is named as you type, for example Line 2: paths must start with /., and Save stays disabled until it is fixed. Variables the Repave IDE sets itself, such as DOCKER_HOST, HOME and anything starting with ANTHROPIC_ or REPAVE_, cannot be changed here. Values are shown to everyone who can open Project Settings, so put a credential in a file and mount it instead.

If a server path does not exist, or the IDE path is one a session already uses, the session does not start and the Repave IDE page names the path to change under Mounted files.

Repave IDE sessions​

The context window a session's assistant runs with, and how it signs in. See Repave IDE.

A session keeps the sign-in it started with, so a save that changes it — the sign-in mode, or the project's API key or other credential the sessions use — stops the sessions open for this project. So does a save that changes what sessions get from the mounted files or environment variables; adding a comment or reordering lines does not. Before saving, Repave asks Stop running Repave IDE sessions? and says how many are open. Stop and save saves and stops them: files on disk are kept, but running terminals and processes end. Cancel saves nothing. A save that changes none of these never asks, and if another session opens while you decide, you are asked again with the new count.

Agent instructions​

On a project that modernizes an app, the Context tab has a card with the agent instructions file of each workspace directory — Root, Legacy and Modernized — as it is on disk now, including one your repository already had. Edit it and click Save & Apply to write the file and commit it, if the directory is a git repository. Only the project owner can save.

If the file changed on disk after the page loaded — an agent or a teammate wrote it — nothing is saved, and the card says so. Click Load current file to replace your edits with the file as it is now; you are asked first if you have edits to lose. A file that could not be read shows why, with nothing to edit.

A project that maintains an existing app has no such card: see Your repository's own instructions.

Repave learning​

At the end of the Context tab, Learn from your developers' changes turns Repave learning on or off. It is off for every project until you turn it on. While it is off, Repave does not read your repositories after a delivery and changes nothing.

Turning it on shows When Repave learns something, with Manual review already chosen.

  • Manual review: Repave suggests changes, and nothing changes until someone adopts them on the Learning page.
  • Auto-adopt: Repave makes each change itself.

Every change can be undone on the Learning page. Both settings are saved with Save Changes. Turning learning off leaves what it already learned, and what it already changed, where they are.

Learning categories​

While learning is on, Repave reads your repository once a day, with the access it already has, and finds the changes your developers made between its delivery and the merge. It sorts each one, so that Repave learns what it got wrong and how your team works. Nothing is sent anywhere your features' code does not already go.

The Learning categories card, below the switch, lists how those changes are sorted. It is shown while learning is on. On a project that maintains an existing app, the Context tab has only the learning cards: your repository keeps its own agent instructions file, which Repave follows and never changes (see Your repository's own instructions). Every project starts with Repave's three kinds:

  • Repave defect, which becomes a check: Repave got something wrong. Repave writes a validation rule for it and suggests the rule only if it catches the mistake in what was delivered and passes your fix. Once adopted, the rule reports on every later feature. Each new rule is written for the kind of code the mistake was in, not only the screen you fixed: a fix to one screen that carried on when its lookup data failed to load teaches a rule for every screen that reads lookup data.
  • Client preference, which becomes a lesson: your conventions, naming, logging and helpers. Repave records it as a lesson for this project, together with the changes it was learned from, and suggests the change to the project's skills it calls for.
  • One-off, which is recorded only: a redesign or extra scope for that one feature.

Each kind has subtypes, such as Authorization or Logging. The description of each kind and subtype is what Repave reads to decide where a change belongs, so write it as a definition. Click ⋯ to edit or remove a kind, click a subtype to edit or remove it, and use Add kind or + Add subtype to add your own. Each change is saved when you click Save or Add in its dialog; Cancel saves nothing. Reset to defaults brings back Repave's list.

Changes you make apply to what is sorted afterwards. A change already sorted keeps the kind it was given, even if you rename or remove that kind later.

Team​

Who can see and change this project. Editors can do the work; viewers can read it. Some controls are owner-only.

Inviting someone gives you a link to send them. If your administrator has set up email in the Admin portal, the invitation is also emailed, and the dialog says whether it was sent. The link opens a page where the invitee signs in, or creates an account with the invited address, and accepts. An invitation expires after 7 days.

Project backup​

Create Backup, on the General tab, makes a ZIP of the project, its files and database records, to restore on another installation, or on this one once the project has been deleted. Only the owner can create or download one.

A backup leaves out the project's API keys and tokens, the Repave IDE environment variables, each repository's access token and each package registry's token or password. A restored project has none of them, even from a backup made by an earlier release that still carried them: enter them again in Settings after restoring. The characterization-test database connection string is kept, so that setup does not have to run again.

A backup holds this project and the people it refers to, and nothing they have elsewhere on the installation: not the organization's settings, their other projects' rows or connections, or their sign-ins to the Repave CLI and MCP clients, which sign in again on another installation. Pending invitations are left out too, so invite anyone who had not accepted yet again after restoring; members who had joined are kept. The ZIP still holds the project's code and data, so keep it private.