How your team's work lands
How a team decides what happens when a dev-pipeline run finishes — land it in the repo, open a pull request, write a tag, or run the repo's own finish command — and how to put a person between "everything is green" and "the work has landed", for one repository at a time.
On this page
Every dev-pipeline run ends the same way it began: with a branch that is finished. What happens next — where that branch goes — is not the same for every team. Some teams merge into the main copy. Some open a pull request and let a reviewer take it from there. Some stamp a release tag. Some hand the branch to a script that does something of their own. And some want a person to look at the finished branch before any of that happens.
When a run finishes is the Setup control that answers that question, one repository at a time.
Where the control lives
It is in the Dev Pipeline panel, not in the app's Settings.
- Open the Dev Pipeline panel.
- On its Setup tab, find When a run finishes, right under "How hands-on do you want to be?". (The same control is also in All settings.)
- Choose a repository from the picker. The panel reads what that repository already does and shows it — nothing is guessed and nothing is written until you press Save.
The card shows four finishes and one switch:
| Choice | What a finished run does |
|---|---|
| Land it | Merges the finished branch into the repository's main copy, after the green check pass. This is the default for a repository that has never said otherwise. |
| Open a pull request | Pushes the run's own branch and opens a pull request against the base branch, so a reviewer can take it from there. |
| Tag it | Tags the checked commit, then makes the same checked merge into the main copy. |
| Run my own command | Runs the command you type, inside the run's own workspace, once everything is green. Whatever that command does is your team's finish. |
| A person approves first | The switch under the four choices. On, the run stops before any of them happen and waits for you. |
Only one finish can be chosen. A person approves first is independent of it: it adds a stop in front of whichever finish is chosen.
What "a person approves first" actually does
This is the part teams ask about most, so it is worth being exact.
A run with the switch on does all of its normal work: it builds, it checks, it commits, and it records what it verified. Then it stops.
- Nothing lands. No merge into the main copy.
- Nothing leaves the machine. No push, no pull request.
- No ready-to-merge tag is written. That tag is what the auto-lander acts on, and a branch waiting for a person must never be picked up by a machine nobody asked.
- The run is not reported as finished. It appears as still running, parked at the final gate, so the panel and the inbox show it as waiting on you rather than quietly closing it.
You then answer it the way you answer any other pipeline stop:
- approved — the run picks up where it stopped and performs the finish that repository chose. The approval releases the finish; it never substitutes a different one. A pull-request repository still opens a pull request, never a local merge.
- feedback — the run stays parked. It addresses what you wrote, re-runs the affected checks, and comes back to the same stop.
- abort — the run ends with nothing landed.
The branch is left verified and untouched, so you can also inspect it yourself before answering.
What happens to a finished branch nobody published
A repository that finishes at a pull request still depends on somebody opening it. If a run ends and nothing publishes its branch, that work sits on the machine and is only found later, when it has drifted far enough to conflict.
So the app watches for exactly that and acts instead of telling you about it. On a computer that does not land work itself, a branch that has finished is handed straight to the agent that publishes pull requests, as the same publish request a person would send by hand:
- Finished means a record says so, never that the branch merely stopped moving. Either the branch was tagged ready to merge, or the app's own ledger has a row for it whose owning session has ended. A branch nothing records — a copy, a probe, an old re-cut — is left alone however old it is, and so is one whose owner is still working or still waiting on you, and one committed in the last half hour.
- Already published means it is on THIS computer's main line, or it has an open or recently merged pull request, or somebody already handed it off. None of those are touched. "On the main line" is measured against your own machine's line, not GitHub's, because your machine's line runs ahead of it.
- Not sure is not the same as missing. If the app cannot prove a branch is unpublished, it leaves it untouched rather than opening a second pull request for work that is already out.
- The audit wave is exempt. A review wave has its own way of publishing, so its branches are never grabbed by this one.
- Tooling is exempt. Your main branch itself, the publisher's own working copies, and the control, probe, re-cut and sync-hold branches the tooling cuts are never treated as finished work.
- Twelve at a time. A backlog is handed over twelve branches per pass rather than in one burst, so the publisher is never buried.
If nobody is holding the publishing seat at that moment, the app does not invent a request nobody will read. It tells your operations agent once, in one message, naming every branch waiting, and checks again later.
Nothing here pushes anything or merges anything. It only makes sure finished work cannot go quiet.
What "run my own command" actually does
The command you type runs in the run's own workspace, with the repository's own tooling, after the checks have passed. It is the same trust boundary as the repository's other commands — the ones that run its tests and its pre-commit steps.
- It exits successfully — the run reports the finish as confirmed and says what it ran.
- It fails — nothing is reported as finished. The run reports the failure and the exit code and stops. It does not fall back to a merge: a repository that chose its own finish must never be quietly landed by a route it did not pick.
- It is left empty — the run refuses and says the repository names a command finish but declares no command.
The command is recorded in the repository, so every teammate runs the same finish.
Where the choice is kept
The choice is written into the repository itself, in .claude/foundations.json, under
pipeline.land:
{
"pipeline": {
"land": { "strategy": "pull-request", "review": true }
}
}
strategy is one of local-merge, pull-request, tag or command; review is true when a
person approves first; command holds the finish command and is only ever present with
strategy: "command". A repository with its own ready-tag step (a "mint") also commits prCommand,
the command that opens its pull requests; Omniscio's own is npm run pr -- --push.
The ready tag is only ever the proof that the checks passed — it is never the finish on its own. Every run checks, marks the checked commit, then does exactly what this control says.
When the pull request never got opened. On a computer that does not land work itself, a repository
set to Open a pull request depends on that pull request: a branch that is tagged ready but never
got one would otherwise wait forever. Every 15 minutes Omniscio compares that computer's ready
branches with the repository's open pull requests, and when a branch has waited 30 minutes with
none, one inbox card — Finished work is waiting for a pull request — lists each branch, its
repository and the command that opens its pull request (Omniscio's own is npm run pr -- --push).
A branch whose work is already on master is left off the card, because it has nothing left to
publish. So is a branch whose own session is still open — still working, or waiting for you —
because that session is the one about to open its pull request; the branch is named once that
session ends. Run that command from the branch's own folder; the card clears by itself once every
ready branch has a pull request, is already on master, or still belongs to an open session. Omniscio never pushes or opens one for you. If GitHub cannot be read, the card says
nothing rather than guessing. Developers can switch the check off with
AMC_DISABLE_READY_WITHOUT_PR_SWEEP=1.
Three consequences matter:
- It travels with the repository. A teammate who clones it runs the same finish, and the file is reviewed like any other change to the project.
- Saving changes only the finish. Every other key in the file — the test commands, the base branch, the docs settings — is left exactly as it was.
- The run reads the main copy, never its own branch. A run reads the choice once, at its start, from the repository's main folder — so a run cannot switch its own finish or review.
- Choosing "Open a pull request" is your yes to push. The run does not ask again each time.
Requirements and refusals
The control records the choice in .claude/foundations.json, so the repository needs one:
- No
.claude/foundations.jsonyet — the control says so and writes nothing. Run Repo Foundations on that repository first (it creates the file), then come back. - A file that cannot be read — the control refuses rather than rewriting it, so a hand-edited or half-written file is never silently replaced. Running Repo Foundations again repairs it.
What this does not do
- It does not change whether a run finishes — every run still finishes. It changes how.
- It does not skip or reorder any gate, and it cannot turn a gate off.
- It does not merge a pull request for you. Opening one is the finish; merging stays a person's decision.
- Turning a person approves first off does not land work that is already waiting. Answer that run — with approval, feedback or abort — as you would any other.
Last verified 2026-11-11