Omniscio

Auto-lander & dev-pipeline settings

Settings reference for the auto-lander, the part of the app that merges finished branches into the main branch on its own: what it must see before it lands something and how much it may spend rescuing a stuck branch. Most are set from the command-line interface or by an agent, so this page is their one written home.

On this page

These decide what the auto-lander — the part of Omniscio that merges your finished branches into your main branch on its own — has to see before it will land something, and how much it is allowed to spend rescuing a branch that gets stuck. Most are set from the CLI or by an agent rather than from a switch on a Settings screen, so most of them have no control for a ? to sit beside: this page is their one written home. The two that do carry an in-app control — auto-preserve uncommitted changes and the stale-tag limit — open this page from that control; the rescue-session model picker has no ? beside it, so its section below is the only written home it has.


PR checklist mode

What the auto-lander does when a branch it is about to merge never went through the pre-merge PR checklist. Off (the default) means the checklist is not consulted at all, so nothing is ever held on its account. Advisory means it works out and records what it would have refused, but blocks nothing — that is how you measure the real cost before arming it. Enforce means it refuses the branch and hands it back to you to finish. Accepted values: off / advisory / enforce.


Require a tests receipt before tagging

The owner can read the combined receipt policy at GET /auto-lander/receipt-policy and set { "mode": "required" } or { "mode": "off" } with PATCH /auto-lander/receipt-policy. This one change covers PR receipts, ready-tag and land-time tests receipts, and the gate-proof, translation proof and test-floor standards. It leaves the guard-baseline and returned-work custody checks in place. The PATCH requires the owner's full-trust CLI token and a source session; agents can read the policy with their scoped tokens.

On by default. A branch cannot be marked ready to merge unless its tests actually ran at the exact commit the tag names — the tag is refused, not stamped and merely doubted later. It is a presence rule: the receipt has to exist and cover that commit, it does not have to be green, because a failure already on your main branch is not this branch's fault. It also refuses a receipt that records a failure the runner attributes to this branch. A branch that changed no code, only docs, or only end-to-end tests owes no test lane and passes. When the answer is missing or stale, the check is re-run rather than the tag stamped.

This lever is separate from every land-time switch below — the lander and the archive merge-back have their own settings, and turning those off does not turn this one off. Turn this off while the check system itself cannot produce receipts (a suspended cloud check lane is the usual reason: the cloud:doctor tool). It is read live on every tag, so no restart is needed.


Require a tests receipt before landing

On by default for one thing: a receipt that records a regression the test runner places on this branch is refused at land time. A missing or stale receipt does not stop a land on its own — the land-time tests arm ships off and only writes down what it would have refused, so an absent or stale receipt is warn-only until you switch that arm on (see Land-time tests arm below). Note what the recorded-regression rule asks for: the receipt has to exist and cover that commit — it does not have to be green, because a red that is already on your main branch is not this branch's fault. It is read live on every land, so suspending it needs no restart. Turn it off only while the system that produces receipts is down, or no branch can earn one and the auto-lander quietly stops landing everything. This is the LAND-side switch; the tag-time check above has its own lever.


A missing tests receipt is not a pass

On by default. This is the presence half of the rule above, on its own lever: turn it off and a branch with no tests receipt at all is allowed through — for the window where the receipt lane cannot run, so absence stops being treated as something a person has to wave through by hand. A receipt that records a real regression is still refused, because that half keeps reading the tests-receipt switch above. Accepted values: on / off.


Land-time tests arm

Whichever way this is set, it does not refuse a branch whose tests are red only because your main branch is already red — it refuses the ones nobody checked. On means a missing, stale, or "the cloud could not say" answer is treated exactly like a failure, because no answer is not a pass. Off (the default) is warn-only: it still works out what it would have refused and writes it down, so you can see the real cost — measured at roughly one land in six — before switching it on. This is the land-time check and is deliberately separate from the tag-time one, which runs once when a branch is first marked ready and never again.


Pause landing while master is broken

On means a confirmed broken main branch actually stops merging, on every route and not just the in-app one: after each merge the app builds your main branch, and if that build genuinely fails, landing pauses so nothing else piles onto the breakage. The pause lifts the moment your main branch builds again. For a confirmed break that passing build is the only release: the hold deliberately does not expire on a clock while the code really is broken, because a check that stops answering is not evidence the break went away. A branch whose own build already passed may still land through the pause — that is how the repair gets in — and the scripts that repair your main branch by pulling from the remote are never blocked, since blocking those would trap you. Only a hold written when no verdict was reached at all lapses on its own deadline, so a check that goes quiet cannot wedge landing. Off (the default) is warn-only, which is the safe way to watch it for a day first.

This setting only ever acts on a build that actually failed. When the build check cannot reach an answer at all — the cloud does not reply, or the check cannot start — landing never pauses, with this setting on or off: you get an alert that master's build state is currently unknown, and merging carries on.


Give landing to Lander V3

Off by default. On hands the landing step to Lander V3, the train lander, and stops the old lander moving your main branch: branches already judged ready are merged in batches called trains, and your main branch moves once per train instead of once per branch. It never switches itself on, and no Settings screen renders a toggle for it — a person turns it on with PATCH /settings/autoLanderLandingV3OwnEnabled, which takes effect on the next land with no restart, or by approving the card the app raises for that switch. Turning it back off is the rollback: your main branch goes straight back to the old lander, nothing needs moving, and no repair step is owed even if V3 crashed mid-train. The setting is not always the truth — the environment or the kill-switch file can hold V3 off while this reads on — so read GET /lander-v3/status (ownSwitch) and GET /settings/autoLanderLandingV3OwnEnabled (effective) to see the real state and what decided it. Every flip is written to the switch history, which GET /auto-lander/switch-history answers.


Run Lander V3 in shadow

Off by default. On runs Lander V3 beside the old lander without letting it move anything: it builds every train it would have landed and records each case where it would have chosen differently, so the cost of a cut-over can be measured before one is made. A branch V3 only deferred counts as no answer, never as a disagreement; a disagreement that turned out to be understood is retired from the alarm with the scripts:run doorway with lander:shadow-explain -- --land-row <n> --note "<why>", which keeps the row and counts it as explained. Shadow is the stage that must run before Give landing to Lander V3, because its comparisons are the evidence a cut-over is judged on.


Auto-preserve uncommitted changes so landing can resume

When on, the auto-lander copes by itself with the commonest reason a landing stalls: uncommitted changes sitting in a paused checkout. It saves them to a recovery ref, clears the checkout, and carries on landing — nothing is discarded, and you get an inbox alert telling you how to get the work back. When off (the default) the residual pause — a change the land cannot safely clear out of the way — keeps landing waiting and asks you to clear it yourself. Read the default the right way round: off does not mean the lander waits on uncommitted work. A change that OVERLAPS the arriving one is already cleared automatically and with no prompt before the land pauses — an untracked file moved to the quarantine folder, a hand-written edit snapshotted to a rescue ref and then restored — so what this setting adds is a wider net over the residue the overlap pass left blocking. And "asks you to clear it yourself" has a time limit for uncommitted edits to tracked files: a checkout that stays stranded for about ten minutes has those edits snapshotted to a rescue ref and reverted by the lander's silent backstop — untracked files are left for you, because the backstop never moves them. See auto-lander dashboard — part 2 for exactly what that pass does to your files, where each piece goes, how to get one back and how to stop it. This setting and the stale-tag limit below both carry controls on the pull-request merge settings screen (Settings → Automations & Rules → PR Merge Queue); the rescue-session model picker is on the Dev Pipeline panel's All settings view, under Auto-lander.


Stuck conflicts are handed back even under load

On by default. While the machine is too busy to land, a branch whose merge conflicts is still handed back to you instead of sitting un-handed-off for hours behind the load gate. It is cheap and rate-limited, and it never lands under load — it only hands back. Set it to false to disable.


How many paid rescue sessions may run at once

How many paid AI rescue sessions the auto-lander may run at once when a branch gets stuck — the sessions that rebase, re-gate and re-tag a stranded branch so it can land on its own. Each one is a billed session, so raising this drains a stranded backlog several-at-a-time instead of about two per half hour, and costs more in parallel. Default 4, maximum 12; capped so a churn storm cannot spawn a swarm and load your machine, and the spawn pacer still paces the actual starts. A repo the auto-lander is not allowed to land — paused, or in observe-only (dry-run) mode — never gets a rescue session, whatever this is set to.

Turning these paid sessions off is not a switch of their own. This number is a ceiling with a floor of 1, so it can never mean "none"; the re-tag sessions below are uncapped while theirs is 0; and the same is true of the backlog-fixer session the auto-lander raises for a repo whose ready branches are not landing. There is no per-session off switch to find. The way to stop the auto-lander starting a paid session is to stop it landing in the first place — pause the repository or set it observe-only, and it gets no rescue or re-tag session whatever the numbers here say, or turn the auto-lander's master switch off to stop them everywhere at once.


Which model the rescue sessions use

Which AI model the auto-lander's paid rescue sessions run on — the sessions that rebase, re-gate and re-tag a stranded branch. The default is the cheap Claude worker tier (claude-worker), not your Claude default model: a rescue runs the most mechanical work in the product against a fully-specified prompt, so the cheap tier drains the same backlog for far less money. Choosing Default instead runs rescues on whatever your Claude default model is — on a normal install the flagship, which costs materially more per attempt. A stronger model is more likely to succeed on a genuinely hard conflict, so it may produce fewer attempts at a higher cost each. Read at spawn, with a Claude fallback if the chosen tier is unavailable.

The same choice also covers landing-queue sessions an agent starts — a session asked to clear stuck branches, prove a branch already landed, or retire or re-tag one. An agent starts one with the landing-queue source and names no engine, so it runs on this model. It always runs on your own computer, never a cloud machine, because a cloud machine only holds a copy of master and cannot see your other branches.


How many re-tag sessions may run at once

How many concurrent stale-tag self-heal sessions the auto-lander may run — the sessions that re-gate and re-tag a branch whose tip moved past its ready tag. Each is a billed session, and not a short one: the heal re-runs the branch's ready-to-merge gate (lint, typecheck and tests) against the branch as it stands and fixes whatever it flags, so it costs about what any gate run costs and can take as long as one. A heal first checks whether there is anything to land at all: when the branch already landed, or its change is provably already on the main branch another way, it does not re-gate — it deletes the branch through the app's delete door, which writes the branch's tip to a backup ref (refs/amc/approved-branch-retire/) before the delete, copied into a verified archive bundle before that ref is ever cleared, and it leaves without a report. It never rebases the branch and never touches the main branch. 0 (the default) means uncapped — it is a real budget of paid sessions, so set a positive number if you want a ceiling. It uses its own budget, so raising it never starves the conflict or translation rescues.


Landing master switch

On by default. The one control that stops every landing at once: off, neither landing engine moves your main branch — nothing is merged, and the branches you marked ready stay ready until you turn it back on. It deliberately stops both the auto-lander and Lander V3, so an incident never has to be stopped twice. This is not the everyday auto-lander on/off (autoLanderEnabled), and it is not a timed freeze: a freeze taken by a session or from the command line lapses by itself, while this switch does not. It lives on the Dev Pipeline panel under Setup → All settings → Auto-lander, and can also be flipped with PATCH /settings/autoLanderSupervisorEnabled with no restart.


Hand main-branch landing to Lander V3

Off by default. On, Lander V3 owns master: the old auto-lander stops moving master — every land it tries is deferred with no strike, and the branch stays ready — while the Lander V3 supervisor starts its worker, and that worker lands the trains and publishes master. A manual land:catch-up run asks this switch too and, with it on, refuses and hands the branch to the Lander V3 door; the Integration Engine batch move refuses at its compare-and-swap the same way. Off, the old lander lands exactly as it always has. If the switch cannot be read, neither lander moves master. It has its own toggle on the Dev Pipeline panel under Setup → All settings → Auto-lander; it can be flipped with PATCH /settings/autoLanderLandingV3OwnEnabled (next land, no restart), and AMC_DISABLE_LANDING_V3_OWN=1 forces it off and wins, which is the rollback.


Lander V3 shadow mode

Off by default. Tells the new Lander V3 to run in shadow: watch the old lander and count where it would have chosen differently, never moving master. The supervisor reads own mode when "Hand main-branch landing to Lander V3" is on, otherwise shadow when this is on, otherwise off; with both on, own mode wins. The old lander never reads it and lands exactly as it always has. It has its own toggle on the Dev Pipeline panel under Setup → All settings → Auto-lander; it can be flipped with PATCH /settings/autoLanderLandingV3ShadowModeEnabled (no restart), and AMC_DISABLE_LANDING_V3_SHADOW=1 forces it off and wins.


Cloud standby merging

Off by default, and it costs money every month while it is on — about $32 for the small cloud machine, its disk and its internet. On means that once this computer has been off or offline for 30 minutes, a cloud machine stands in for it: it lands other developers' pull requests that carry a valid receipt, come from an approved developer and merge cleanly, one at a time, and it hands the job straight back the moment this computer returns. It never lands anything this computer would not, and off means the app makes no cloud call and changes nothing about how it lands or publishes. Switching it off is confirmed rather than best effort: the app keeps retrying until the cloud standby reads back as disarmed, and raises one inbox card if that takes longer than ten minutes. The toggle sits on the pull-request merge settings screen, under Settings → Automations & Rules → PR Merge Queue, in the Repos tab.


Approve ready-to-merge requests from agents automatically

Off by default, and it lives on the Dev Pipeline panel's Setup screen (Dev Pipeline → Setup → All settings → Auto-lander). When an agent wants to mark a branch ready to merge while one of its checks is failing — usually because the failure is already on your main branch and not this branch's doing — it normally stops and raises a card in your inbox for you to approve. On, the auto-lander approves that card for you and the work keeps moving; each approval is still recorded, and anything you have personally rejected stays rejected. Turning it on hands the agent a lever it otherwise cannot pull, because the click is the whole mechanism: a credential says who holds it, never who clicked. That is why switching it on is a human action only — an AI agent cannot set it for you, and neither can your phone. Read live on every ready-to-merge request, so a change needs no restart.


Held branches release themselves

There is no Owner sign-off button and no setting for one. A held, parked, stuck or returned branch is released by the session that owns it — its own author, the session that launched it, or any live member of its crew — through the ordinary ready mint. Nothing is tagged on your say-so from a card, and no card asks you to click anything to unblock an agent's work. The ready-to-merge checks are unchanged: a failing security suite, a red the test runner placed on that branch, drift from the approved commit, unproven deletions and a change that runs by itself once landed all still refuse.