The Repowise PR bot is a GitHub App that runs the same intelligence layers as the CLI and dashboard against every pull request. It posts one short comment, with a checks section when coverage, security or docs have something to say, optional pass/fail checks a branch rule can require, and review threads on the lines that need them. Every push gets a Repowise review check with the commit it reviewed and its finding counts. In Signals the comment is deterministic and posts only when there is something worth saying: no model, no per-PR tokens, and free forever for public / OSS repos. AI review adds an AI review of every pull request that changes code. It comes with the paid plans (Pro and Teams), is billed from credits, and is on by default for repos a paid plan covers. Private repos need a paid plan too. See review modes.
Install it from the GitHub App page: github.com/apps/repowise-bot. Pick individual repos or a whole org. There is also a marketing overview and you can manage installs from the dashboard.
Setting it up with a coding agent? Point it at Set up the PR bot (for agents): ordered steps with the commands, the links for the person, and the checks.
Install
Install the GitHub App. Open github.com/apps/repowise-bot, choose the repos (or the whole org), and approve.
Connect the install to your account. GitHub sends you back to
repowise.dev/bot/installed, which shows a "Finishing setup" state while it
waits for GitHub's webhook to register the installation. It polls for that on
its own, up to eight times at 1.5-second intervals, and tells you if
registration is taking longer than expected. Two cases from there:
- Personal account install. Claimed automatically as soon as you are signed in. Nothing to click. If the claim fails the page says so and offers a retry button.
- Organization install. An organization admin has to confirm it. The page shows a "Confirm organization access" button, which needs a GitHub sign-in fresh enough to carry a provider token; without one the button is disabled and the page asks you to sign in with GitHub again.
If you are not signed in at all, comments still appear on pull requests. You just cannot manage the install or claim the indexed repos until you sign in.
Indexing starts. Once the install is connected, the default branch of each
covered repo is indexed through the same pipeline the hosted dashboard uses,
typically 3 to 10 minutes per repo. Until a repo's first snapshot exists the
page lists it as indexing.
A first review. Right after you install, the bot reviews the most recently updated open pull request on up to three of the new repos, so you see a review without waiting for a push. It picks ready-for-review pull requests opened by a person, on public repos and on private repos a paid plan covers, once per repo. This first review runs the free checks only and spends no credit.
Open a pull request. On opened / synchronize / reopened, the bot
re-parses the changed files, computes the health delta between base and head,
and decides whether to comment.
Read the report. The View on Repowise button on each comment opens
the pull request's page on repowise.dev (/pr/{owner}/{repo}/{number}),
with the full analysis, findings and tests to run. Pages for public repos need
no sign-in. Pages for private repos open for signed-in users with access to
the repo.
Permissions requested: Contents: Read · Pull requests: Write · Metadata: Read · Issues: Write (GitHub treats PR comments as issue comments) · Checks: Write, for the Repowise review check, the merge gate, pass/fail checks and annotations on lines. Grant Checks: Write: without it the bot still comments, but a pull request with nothing to act on under the free checks gets no comment, so nothing on it shows the review ran. The one-click coverage setup needs Contents: Read and write and Workflows: Read and write.
Review modes
The org policy picks the mode for every repo
in an installation, and a repo can override it (Settings → PR bot). The mode is
set on the dashboard or through the API
(PATCH /github-app/bot-repos/{repo_id}/config, see
AI review settings). The
bot ignores review_mode in .repowise/bot.yaml, so a pull request from a fork
cannot turn on a paid pass.
| Mode | What it does | Plan | Cost |
|---|---|---|---|
| Signals | Comments when a contract breaks, a finding lands, or the checks have something to say. No model runs. | Free on public repos | None |
| AI review | Signals plus an AI review of every pull request that changes code, on every push except a rebase that changes no code. Docs-only and other non-code pull requests get Signals. | Pro or Teams | About 15 cents a reviewed pull request, billed from credits, within a per-PR and a monthly limit |
When no one has picked a mode, a repo whose installation is claimed by an account on a paid plan gets AI review, and any other repo gets Signals. A mode picked in the org policy or the repo's settings always stands.
How AI review works
- A deep review on every push. AI reviewers hunt the diff for bugs with the evidence Signals already computed: callers, co-change partners, findings, tests. Every point is checked against the code before it posts.
- Fix pushes are incremental. A later push is read for what changed since the last reviewed commit. The review remembers its earlier points, so a point is never raised twice, and a point whose lines a push fixed is resolved on its thread.
- A quick pass when the budget is low. Once a pull request had a deep review and its remaining budget cannot pay for another, later pushes get the quick pass: one AI pass over the change, with a verifier on its risky claims.
- Tests in one thread. Changed code that no test reaches is listed once, in a single "Tests for this change" thread, edited in place as pushes land.
- Drafts. A draft pull request gets the quick pass. The deep review runs once it is marked ready for review.
- On demand. Comment
/repowise review deepto run the deep review on the current commit, whatever the depth, draft state or per-PR limit say.
Depth (review_depth) sets how far AI review goes:
| Depth | Runs |
|---|---|
light | The quick pass and its verifier. No deep review. |
auto | The quick pass, plus the deep review once per pull request when high change risk, a breaking change with outside callers, a large change or a security-sensitive path calls for it, or two of hotspot history, a health drop, a severe new finding and a missing co-change partner. |
deep | The default. The deep review on every push until the pull request's budget is spent. After the first deep review, a push the remaining budget cannot pay for gets the quick pass. |
One pull request can run at another depth with an effort label.
Sensitivity (review_sensitivity) sets how many points a review posts:
| Sensitivity | Posts |
|---|---|
quiet | Up to 3 points, only what would hurt. |
balanced | The default. Up to 5 points, leaving out minor ones. |
thorough | Up to 10 points, with a longer, more thorough search for narrow real defects. |
AI review draws on the same credit balance as chat, docs and MCP, with no
per-seat review fee. A reviewed pull request uses about 15 cents of credit, so
$5 covers about 33. Pro includes $5 of credits a month; on Teams, a repo shared
into the team draws on the team's credit pool. Two limits bound the spend: each
pull request has one (ai_pr_cap_cents, 60 cents by default) and each
repository a monthly AI spend limit (ai_monthly_cap_cents, $10 by default; 0
turns AI review off). When credit runs out or the repository reaches its monthly
limit, the bot falls back to a light review, a single quick AI pass, and says so
on the pull request. The line names the cause:
- Credit ran out: "Light review: AI credit ran out. Add credits for the full review."
- The repository reached its monthly limit: "Light review: this repository reached its monthly AI limit. Raise the limit for the full review." The owner raises it in the repo's bot settings; adding credits does not lift it.
On a public repository the line reads "Light review on this push. The repository owner can restore the full review." Repowise funds the light review from a small monthly reserve; once that is used, the pull request gets the free checks only, and the comment and the review check say AI review is paused. When the plan does not include AI review, the bot posts only what Signals would, and the comment and the review check note it. When a pull request's own limit is spent, later pushes get Signals and the review check says the pull request's AI budget is spent.
When the bot comments
In Signals the bot stays silent unless there is a measurable signal worth interrupting a reviewer for. Under Signals, a pull request with nothing to act on gets no comment. With AI review on, a clean push gets one short comment saying it is safe to merge and what was checked, edited in place on each push, and a push with points gets the full review. The Repowise review check reports every push either way. When the bot does comment, improvements are shown alongside problems so cleanup gets credit. Signals posts when any of these fire:
- a changed signature still has callers outside the pull request that are not tests;
- the pull request's added lines introduce a finding at or above
introduced(highby default), outside test files; - the checks section has something to say: changed lines no test
covers, changed files no test reaches, or a security finding at or above
security_shows_at; - a refuted claim in a doc the pull request edits, when
doc_driftis set to a confidence; - damage an earlier commit did to a changed file, when
recent_declineis set to a severity.
A co-change partner left out of the pull request is added to a comment that
posts, but never posts one on its own. Health scores, hotspots, dead code and
change risk are context: they appear in a comment that posts. Set
comment_mode: always to get the comment, with a clean bill of health, on
every pull request.
The bot edits its existing comment when new commits land instead of posting a wall of duplicates. If nothing is left to say after an earlier comment, the comment turns into the short clean one with AI review on, and is deleted under free checks.
What's in the comment
The comment is short and leads with what the reviewer should do. Each part
renders only when it has something to say, and the full analysis is one click
away: the View on Repowise button opens the pull request's page
(/pr/{owner}/{repo}/{number}), and each review thread has a Details link
to its point on that page.
| Part | What it shows |
|---|---|
| Verdict and review actions | The evidence that made the bot post, as actions: a broken contract, a finding this PR introduced, a missing companion file, the tests to run. At most three. |
| Health line | The repo score and how this PR moved it (show_health). |
| Gate line | The merge gate's verdict, when the gate is on. |
| Coverage | One verdict line: patch coverage of the changed lines, the project delta, and the threshold when one is set. The uncovered changed lines are folded under it, per file, each range linked to its lines. Measured, and only when CI uploads a report (see coverage setup). Nothing renders while CI is still running. |
| Security | New findings on the lines the pull request adds, at or above security_shows_at. Secrets are masked. |
| Tests | Only when there is no coverage report and none is coming: the changed files no test reaches through the call or import graph. Inferred, so it never shows a percentage. |
| Doc drift | Opt-in (doc_drift). Refuted claims in docs the pull request edits. Documents that only name a changed file stay on the PR page and in the Repowise / doc drift check run. |
| Evidence | A folded table of what is known and unknown about the change: owners, components, provenance with its coverage. Off by default (show_evidence). |
| Reviewers | Suggested reviewers (show_ownership). Standard detail only. |
Coverage, security, tests and doc drift form the comment's checks section (see checks). In Signals nothing in the comment is written by a model, so every comment is reproducible. AI review writes its part with a model, and the pull request page names the model that wrote it.
Findings on lines
on_lines decides what lands on the changed lines themselves:
| Value | What it posts |
|---|---|
off | Nothing on the lines; the findings stay in the comment. |
annotations | Check Run annotations in Files changed: high and critical health findings on lines this PR added, and changed signatures that code outside the PR still calls. With the merge gate off they ride on a neutral check posted only when there is something to mark. |
threads | The default. The strongest findings as review threads you can reply to: leaked keys, breaking signature changes with outside callers, and AI review points. |
both | Annotations and threads. |
AI review points on code this PR wrote are capped by the review sensitivity.
The Repowise review check
Every push gets a GitHub check run named Repowise review. It is on by
default, and it tells people and coding agents whether the latest commit has
been reviewed and what the review found:
| State | Conclusion | Title |
|---|---|---|
| Review running | in_progress | Reviewing <short sha> |
| Waiting for the repo's first index | in_progress | Waiting for the first index |
| Clean, AI review accepted | success | Safe to merge · quick review or Safe to merge · deep review |
| Clean, part of the change not analysed | success | No open points · quick review, 2 files not analysed |
| Clean, free checks only | success | Nothing to act on · free checks |
| AI answer rejected | success | Nothing to act on · quick review rejected, free checks ran |
| Points | neutral | The open points, with the depth that ran, for example 3 points to look at · deep review; the split by priority is in the summary |
| Pull request's AI limit reached | neutral | Nothing to act on · AI limit reached for this PR, or the open points |
| Skipped | neutral | Not reviewed: <reason>, for a [skip repowise] or do-not-merge title, a bot author, the bot turned off, a plan that does not cover the repo, a pull request too large, or no files to review |
| Superseded by a newer push | neutral | Superseded, with the newer commit |
| Did not finish | neutral | Comment /repowise recheck to run it again |
The title names the depth that ran: a quick review or a deep review, or free
checks when no AI review ran. The title is for people. Tools should read the
check's conclusion and the JSON status in its text (status, open and
tier), not the title. A run paused for credits or the plan is a normal clean
or points run with a note line in its summary. The
summary names the reviewed commit and the base it was compared against.
The check concludes failure only when the merge gate is on
and blocking. Keep it out of required checks unless the gate is on.
For coding agents. The latest commit is reviewed when the
Repowise review check on the head SHA is completed. Read the check's
finding counts instead of comparing comment timestamps. When the bot posts a
comment, its hidden repowise-bot marker also carries the reviewed head SHA.
A pull request with nothing to act on under the free checks gets no comment, so
on an install without Checks: Write there is nothing to read: grant it.
The check's text lists every review point and new health finding with its file and line, rule and evidence. On a private repo, that is the copy an agent reads with GitHub access alone:
gh api 'repos/OWNER/REPO/commits/refs/pull/N/head/check-runs?check_name=Repowise%20review' \
--jq '.check_runs[0].output.text'The full analysis is at https://repowise.dev/pr/OWNER/REPO/N.md. On a
private repo it answers the account that installed the bot and anyone the
repo is shared with, signed in on repowise.dev or with
Authorization: Bearer <Repowise API key>. Anyone else gets a 404.
To turn the check off for a repo, set review_check: false.
Commands
Comment on a pull request:
| Command | Does |
|---|---|
/repowise recheck | Runs the review again on the current commit. |
/repowise review deep | Runs the AI deep review on the current commit (AI review only). |
/repowise remember [path:<glob>] <text> | Saves a review preference the bot reads on later reviews. Works in review threads too. |
/repowise confirm | In a review thread: accepts the decision saved from it. Needs write access. |
/repowise forget | In a review thread: undoes what was saved from it. Needs write access. |
/repowise help | Lists the commands. |
Put [skip repowise], or a do-not-merge marker such as DNM, in a pull request title to skip it.
Effort labels
A label sets the review depth for one pull request, over the repo's
review_depth:
| Label | That pull request gets |
|---|---|
repowise: deep | Deep review |
repowise: light | Light review |
repowise: off | Signals only, no AI |
A label wins over /repowise review deep, the repo setting and the org policy.
When the org policy locks the depth, the bot ignores the labels, and a
/repowise review deep comment still runs one deep review. The bot never creates the labels: type
one in GitHub's label picker, which offers to create it the first time, or run
gh label create. Adding repowise: deep or repowise: light runs the review
again on the current commit. The gh commands for an agent and how to read
what ran are in
the setup runbook.
Teach the review
Reply on one of the review's findings to tell it what your team does, for example "we validate this at the API boundary, not here". The review saves the reply as a decision and applies it to later reviews, and answers on the thread with what it saved and a link to it.
- Write access accepts it. A reply from someone with write, maintain or admin access on the repository is accepted right away: "Saved as a decision (accepted: octocat has write access)". Anyone else's reply is saved for someone to accept.
- Accept from the thread. Reply
/repowise confirmon the thread to accept a saved decision, or confirm it on the repository's Decisions page. - Undo. Reply
/repowise forgeton the thread. The decision stops shaping reviews, and a finding the reply had quieted can be raised again.
The Learn from replies setting, in a repository's bot settings or the org policy, picks what a reply becomes:
| Option | Does |
|---|---|
| Accept automatically when the replier has write access | The default. Replies from people with write access are accepted, others are saved for someone to accept. |
| Save for someone to accept | Every reply is saved, and nothing shapes reviews until someone accepts it. |
| Don't learn from replies | Replies are not saved. |
What the review learned on a repository is listed under What it learned from your team in that repository's bot settings. Teammates who did not install the bot can see it there; only the person who installed the bot can change the setting.
The merge gate
Beyond commenting, the bot can post a GitHub Check Run named
Repowise / code health that a branch protection rule can require, turning
code health into a merge gate. It is off by default (health_gate.mode):
off: no check is created.advisory: always concludesneutral. The verdict is visible on the PR but never blocks. The safe default to start with.blocking: concludesfailurewhen a rule trips, which a required check will block the merge on.
The rules (evaluated only in blocking mode):
| Rule | Blocks when |
|---|---|
repo_drop_block | The repo health score drops by more than this many points (default 0.3). |
min_new_file_score | A changed file scores below this floor, out of 10. |
block_on_introduced | The PR introduces a finding in its added lines. |
block_at | With block_on_introduced, the lowest severity that fails: critical, high, medium or low. Unset means any severity. |
Or start from a named profile and nudge single knobs: health_gate.profile
accepts warn-only, block-new-file-floor or block-any-decline. The
profile seeds the rules; any explicit key set alongside it wins.
not_evaluated decides what every Repowise check run concludes when it
could not evaluate, for example no health score yet or no coverage report:
neutral (the default) passes a required check, failure holds the merge
until it can evaluate.
Because the bot already re-scores the repo at both the base and head commits, the gate needs no extra index; it reads the same per-PR analysis the comment is built from.
Checks
The comment's checks section carries what the tests, the security scan and the
docs say about the change (see what's in the comment).
checks_comment decides when it renders:
on_signal(the default): only when a check has something to say. Once shown it is always updated, to an all-clear line when the findings are gone, so a stale finding never lingers.always: on every pull request.off: never.
Pass/fail checks
Each check can also post its own GitHub check run, which a branch protection
rule can require. check_runs lists the ones that run. review (the
Repowise review check) is on by default, the
rest are off, and all work with or without the checks section:
check_runs entry | Check run | Fails when |
|---|---|---|
review | Repowise review | Only with a blocking merge gate. Otherwise success when clean and neutral with findings. |
coverage | Repowise / coverage | Patch coverage is below coverage_fail_under (a percent, 0 to 100). With no minimum it reports the figure and concludes neutral. |
security | Repowise / security | The pull request adds a finding at or above security_fail_on (high by default). |
doc_drift | Repowise / doc drift | A doc the pull request edits carries a claim the code refutes, at high confidence. |
A check that could not evaluate concludes as not_evaluated says.
Coverage setup
The coverage check reads the line coverage your CI uploads for each commit and matches it to the lines the pull request adds. Two ways to start the upload:
- Let the bot open the pull request. In the dashboard (Settings → PR bot →
a repo's settings → Checks), Set up coverage has the bot open a draft
pull request that adds the upload to your CI. When one workflow job clearly
runs your tests on pull requests, it adds coverage to that job; otherwise it
adds
.github/workflows/repowise-coverage.ymlfor the detected stack. Review it, mark it ready and merge it; the next pull request carries a coverage line. A repo with no upload yet also gets a Set up coverage link in the comment. - Add the upload step yourself. Add it to the job that runs your tests,
after the step that writes the coverage report, and give the job the
id-token: writepermission. SetREPORTSto your report paths or globs.
The one-click setup needs two extra repository permissions on the PR bot: Contents: Read and write and Workflows: Read and write. Existing installs see "Approve the new permission" in the dashboard, which links to the installation's settings on GitHub. Everything else (the checks section, check runs, uploads) works without them.
jobs:
test:
runs-on: ubuntu-latest
permissions:
contents: read
id-token: write # lets the upload prove it comes from this repository
steps:
# ... check out, install, and run your tests with coverage ...
- name: Upload coverage to Repowise
if: always()
continue-on-error: true
env:
REPORTS: "coverage.xml" # space-separated paths or globs
HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
PR_NUMBER: ${{ github.event.pull_request.number }}
RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
run: |
shopt -s globstar nullglob
files=()
for pattern in $REPORTS; do for f in $pattern; do [ -f "$f" ] && files+=(-F "report=@$f"); done; done
if [ ${#files[@]} -eq 0 ]; then echo "::warning::Repowise: no coverage report found at: $REPORTS"; exit 0; fi
auth=()
if [ -n "${ACTIONS_ID_TOKEN_REQUEST_URL:-}" ]; then
token=$(curl -sS -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=repowise" | jq -r '.value // empty' || true)
[ -n "$token" ] && auth=(-H "Authorization: Bearer $token")
fi
curl -sS --fail-with-body --max-time 60 "${auth[@]}" "${files[@]}" \
-F "repository=$GITHUB_REPOSITORY" -F "head_sha=$HEAD_SHA" -F "pr_number=$PR_NUMBER" \
-F "event=$GITHUB_EVENT_NAME" -F "run_url=$RUN_URL" -F "workspace=$GITHUB_WORKSPACE" \
https://api.repowise.dev/ci/coverage \
|| echo "::warning::Repowise: coverage upload failed; see the message above."The step never fails the job: a missing report or a failed upload is a warning in the log. It needs no secret: the workflow's identity token proves which repository the upload comes from. A pull request from a fork gets no such token, so its upload is accepted only on a public repository and labelled as unverified; on a private repository fork uploads are refused.
For report formats and per-language coverage commands, see
test intelligence and
Repowise in CI. An upload from a push run on the default branch
also fills the repo's Tests page and the hosted MCP tools; uploads from
pull request runs feed the pull request's coverage check.
Checks settings
| Key | Default | Meaning |
|---|---|---|
checks_comment | on_signal | When the checks section renders: off, on_signal or always. |
coverage | show | Coverage in the comment: off or show. check_run shows it and also runs Repowise / coverage. |
tests_reach | true | Name the changed files no test reaches when there is no coverage report. |
show_security_check | true | Security in the comment. |
security_shows_at | med | Lowest severity shown: high, med or low. |
doc_drift | off | Doc drift in the comment: off, show, or a confidence (high, medium, low) at which a refuted claim alone posts the comment. |
check_runs | [review] | Check runs: any of review, coverage, security, doc_drift. |
review_check | true | The Repowise review check. false turns it off even when check_runs lists review. |
coverage_fail_under | none | Patch coverage percent below which Repowise / coverage fails. Empty reports only. |
security_fail_on | high | Lowest severity that fails Repowise / security: high, med or low. |
not_evaluated | neutral | What a check run concludes when it could not evaluate: neutral or failure. |
Configuration
Settings come from layers, lowest first; a higher layer wins for each key it sets:
- the bot's defaults;
- the org policy of the installation;
.repowise/bot.yamlin the repo;- the repo's own settings on the dashboard;
- the keys the org policy locks.
Policy keys decide a gate, so a pull request cannot loosen them from its own
branch: enabled, health_gate, check_runs, coverage_fail_under,
security_fail_on, not_evaluated, review_check, feedback_decisions,
ignore_paths and apply_labels are read from .repowise/bot.yaml on the
base branch only. Paid keys (review_mode, review_depth, ai_pr_cap_cents,
ai_monthly_cap_cents) are set on the dashboard or through the API
(PATCH /github-app/bot-repos/{repo_id}/config), never from
.repowise/bot.yaml. ignore_paths is a
union across layers, so a layer can add scope but never un-ignore a path
another layer skips. A malformed value is skipped and the layer below stands.
Keys
The checks keys are in checks settings and the merge gate's in the merge gate.
| Key | Default | Values and meaning |
|---|---|---|
enabled | true | Turns the bot on or off for the repo. |
review_mode | signals, or ai when a paid plan covers the install | signals or ai. Dashboard or API. |
review_depth | deep | light, auto or deep. See how AI review works. Dashboard or API. |
review_sensitivity | balanced | quiet, balanced or thorough. |
ai_pr_cap_cents | 60 | AI spend per pull request, in cents. Dashboard or API. |
ai_monthly_cap_cents | 1000 | AI spend per repo per calendar month, in cents. 0 turns AI review off. Dashboard or API. |
comment_mode | on_signal | on_signal posts only when something fires; always posts on every pull request. |
verbosity | standard | compact (actions, health, gate) or standard (adds the evidence table and suggested reviewers). detailed renders as standard. |
introduced | high | off, show, or a severity (critical, high, medium, low) at which a new finding posts the comment on its own. |
recent_decline | show | Same values. Damage an earlier commit did to a changed file; show never posts on its own. |
change_risk | signal | off, signal (PR page, check and labels) or comment (also a line in the comment). |
on_lines | threads | See findings on lines. |
feedback_decisions | auto_accept | off, propose or auto_accept. See teach the review. |
apply_labels | false | See PR labels. |
ignore_paths | none | Globs the bot skips. |
show_summary, show_health, show_hotspots, show_ownership, show_coupling, show_dead_code, show_refactoring, show_review_priority, show_checklist, show_change_map, show_declining_alert | true | Show or hide each part of the comment. |
show_evidence | false | The folded evidence table. |
Org policy and repo overrides
Settings → PR bot → an installation opens its org policy: the settings every repo it covers starts from. It offers three presets:
| Preset | Sets |
|---|---|
| Quiet | Posts only for critical findings. No pass/fail checks, no merge gate. |
| Standard | The bot's defaults: posts for high-severity findings, no pass/fail checks, no merge gate. |
| Strict gate | Posts from medium severity, check_runs: [coverage, security], a blocking merge gate, and not_evaluated: failure. |
No preset changes the review mode, which is a paid choice of its own. The page shows how many repos follow the preset (override none of its keys), and can make selected repos follow it: after a confirmation naming the repos and the settings, it clears their overrides of the preset's keys and leaves the rest.
Each policy row has a lock. A locked key wins over the repo's dashboard
settings and its .repowise/bot.yaml, so a repo cannot loosen it; the repo's
page shows the row read only. Locking a key the policy does not set yet pins
the value the repos get at that moment. The merge gate locks as one key.
A repo's page (Customise on the policy, or Settings on a repo row)
shows every setting with its value and where it comes from: Default,
Org default, Overridden or Locked by org. A change there overrides
the policy for that repo; Reset on a row, or Reset all to org default,
removes the override. The dashboard cannot see .repowise/bot.yaml, so a value
marked Default or Org default may still be changed by the repo's YAML.
.repowise/bot.yaml
Committed and versioned with the code:
bot:
enabled: true
comment_mode: on_signal # or "always" to post a clean bill of health
verbosity: standard # compact | standard
introduced: high # off | show | critical | high | medium | low
recent_decline: show # same values; "show" never posts on its own
change_risk: signal # off | signal (PR page) | comment
on_lines: threads # off | annotations | threads | both
apply_labels: false # opt in to repowise:* PR labels
ignore_paths:
- "vendor/**"
- "**/*.generated.*"
health_gate:
mode: advisory # off | advisory | blocking
repo_drop_block: 0.3
min_new_file_score: 7.0
block_on_introduced: true
block_at: high
checks_comment: on_signal # off | on_signal | always
check_runs: [review, coverage] # review | coverage | security | doc_drift
coverage_fail_under: 80 # percent of changed lines; omit to report only
not_evaluated: neutral # neutral | failureThe comment's parts each have a switch: show_health, show_checklist,
show_coupling, show_ownership, show_evidence and show_declining_alert.
Pre-v2 key names (show_introduced with introduced_posts_at,
inline_threads, show_findings_on_lines, coverage_check_run,
checks_comment_mode and the rest) still read into the key they became.
PR labels (opt-in)
With apply_labels: true the bot also applies repowise:* labels, created on
demand and reconciled on every run: a label is removed once its signal clears,
and labels outside the repowise: namespace are never touched.
| Label | Applied when |
|---|---|
repowise:gate-failed | A blocking gate you configured actually tripped |
repowise:risk-high | Top tercile of this repository's own commit-risk distribution |
repowise:missing-tests | A file with recent fix history changed, and no test that imports it was touched |
repowise:size-xl | Too large for granular analysis |
They are off by default, and the list is short on purpose. A label is permanent, binary, and public in the pull-request list, so it reads as a verdict on the author in a way an editable comment does not, which means it has to be reserved for things that are actually rare. Signals that fire on ordinary work (a repo score that dipped, a hotspot touched, a moderately-sized diff) stay in the comment, where they carry their context with them.
Pricing
| Public repos | Private repos | |
|---|---|---|
| Free | Signals: the comment, the checks, the merge gate and the review check. No model, no tokens. | A notice on each pull request with a link to start a paid plan. |
| Pro or Teams | Signals and AI review | Signals and AI review |
AI review is billed from credits on every repo, public ones included (see review modes). A private repo is covered when the account that claimed the installation is on a paid plan, or when an account on a paid plan has added that repo in Repowise. See the pricing page.
FAQ
Does the bot post on every pull request? It keeps one comment per pull
request and edits it on every push. Under Signals, a pull request with nothing
to act on gets no comment, and the
Repowise review check still reports it. With AI
review, a clean push gets one short comment saying it is safe to merge and what
was checked. Set comment_mode: always to get a comment on every pull request.
Does Signals run a model? No. Signals comes from the repository's index: parsed code, the call graph, git history and the health scorer. A model runs only for AI review.
Who pays for AI review? The account that claimed the installation, from its credits, or the team's credit pool when the repo is shared into a paying team. On an installation nobody has claimed, the first account on a paid plan that added the repo pays. AI review runs only on a paid plan, public repos included.
Can a pull request turn on AI review or raise its limit? No. review_mode,
review_depth and both AI limits are set on the dashboard or through the API,
never from .repowise/bot.yaml, and gate keys are read from the base branch, so
a fork cannot loosen them.
Do bot-opened pull requests get reviewed? No. Pull requests opened by bots (Dependabot, Renovate and the like) are skipped, and the review check says so.
How do I skip one pull request or one path? Put [skip repowise], or a
do-not-merge marker such as DNM, in the title, or add globs to ignore_paths in the dashboard or .repowise/bot.yaml.
To turn the bot off for a repo, use the toggle in its settings or set
enabled: false.
Does it change my code? No. The one change the bot can open itself is the draft pull request that adds the coverage upload, for you to review and merge.
How it relates to the rest of Repowise
Same engine, different surface. The bot reads the code-health,
git-intelligence, and
dependency-graph layers, and every
comment links to the pull request's page on the dashboard, where the same data is queryable
by humans (the web UI) and by AI agents (the MCP tools,
including get_health for a pre-PR self-check).