The fix is already written.
You decide if it ships.
RepoOps senses a problem in your repo or in production, scopes it, builds the fix as a pull request in a sandbox, and proves it works five ways. What reaches you is a finished, CI-green pull request behind one decision. Approve it and the lesson that stops it happening again is written in the same move.
Free and local for one developer · nothing merges without your yes · the machine never approves its own work
The loop
Nine stages. One of them is yours.
Everything before the gate is cheap and reversible. Nothing after it happens without your explicit yes.
- 01Sense
- 02Triage
- 03Scope
- 04Build
- 05Verify
- YouApprove
- 07Ship
- 08Learn
Sense runs twice, over your repo and over production. Repeated sightings of one issue fold into a single case rather than opening hundreds.
A fix that misses one is never shown to you. It goes back to the builder once with the failure attached, then stops loudly with both attempts recorded.
Approve or reject. The merge seam is never touched unless the whole bar passes again, server-side, at the moment you press it.
Auto-merge is off on every pull request the loop opens. Your build policy bounds what runs unattended before the gate.
The queue
Your job is the decision, not the diagnosis.
The Today page holds what is built and waiting on you, what is building right now with its live metered spend, and what your policy is holding back on purpose.
Null deref in the invoice labor line when a client has no budget id
Illustrative. Every field here is one the real card renders from the case record.
Why you can trust the diff
An agent that cannot widen its own job
The brief is the leash
The scoper writes a brief for cents: root cause, the files to touch, what done means, what is out of scope. At dispatch those file names are frozen onto the build record.
At verify, a changed file passes only if the brief named it, or it is a new test beside the change. Anything else fails, with the files named in the reason. That is what stops a one-line fix quietly becoming a refactor.
The regression test is proved both ways
A new test has to pass on the fix and fail when grafted onto the commit that caused the defect. A test that passes on both proves nothing, so it does not count.
The guard is replayed against that same commit and has to block it.
Nothing it cannot ground
A finding the scoper cannot ground gets a recorded decline with its reason, never a guess.
An out-of-repo step, rotating a leaked key or replaying dropped webhook events, is named as yours on the approval card rather than implied handled.
The half that compounds
The same bug does not come back
A fix closes one incident. A lesson closes the class of them. Approval does both in one move, and the reversible half lands first.
Approve writes the lesson, then merges
The lesson is drafted from the brief's done-means while the fix is still being built, so you read it before you decide. On approve it is saved first, because it is the reversible write, and the merge follows.
The guard blocks the next one
Approval arms the guard against the mistake that caused the incident. For a security case with a catalog rule, that is the detector's own pattern. The prevention ledger then counts what it actually catches.
Lessons reach the next session
The top-ranked lessons are written into the agent's own operating manual automatically, so the next session starts already knowing. The rest stay on the Lessons tab, ranked by what they have prevented.
Your policy, your pace
You set how far it goes without you
A build floor and a daily cap
Below the floor, a case waits for you and says so on the queue. Above it, the loop may build unattended, bounded by a daily cap and a watch-only switch you hold.
Local first, and yours
Sessions, costs and lessons land in local files you own. A production connection keeps its token in your local data directory, never in the first-run intake, and a fresh connect backfills 30 days.
Ask for the transcript, with consent
A team owner can ask the developer bound to an incident for that one session's transcript. Only the developer can grant it, in their own local app, and no hosted code path can write that grant for them.
Auto-remediation is off until you turn it on. The loop builds only what your policy allows, opens every pull request with auto-merge off, and shows you nothing that failed a recorded check. It does not claim to fix everything: what it cannot ground, it declines in writing.