Omniscio

Auto-lander dashboard

The Auto-lander dashboard — the Auto-lander view in the Dev Pipeline panel, opened from the Runs screen, where you watch the auto-lander's live status, see where each of your branches is and what it is waiting on, read the history of what it has landed or handed back, and pause or resume the lander or a single repository.

On this page

Receipt requirements from the CLI

The owner can read the policy with GET /auto-lander/receipt-policy and change it with PATCH /auto-lander/receipt-policy and { "mode": "required" } or { "mode": "off" }. The policy covers local ready tags, auto-landing, cloud-returned work, and incoming pull requests. Its four backing switches (prReceiptMode, mintTestsReceiptRequired, landerTestsReceiptRequired, landerTestsPresenceRequired) are all refused by the generic PATCH /settings/:key route, so this grouped control is the only road and the policy can never be left partially suspended one key at a time. An off policy lets work proceed without missing check receipts or replacement verification; it does not turn off independent content, authorization, or merge checks. Agents should read the effective policy before asking for a receipt waiver. Changes take effect on the next decision without a restart or a second approval.

Under a required policy the mint refuses a ready stamp whose own receipt records no verdict for a check the policy owes — the shape a cloud mint leaves when it publishes a branch with an empty verdict list. The refusal names each missing check with the command that produces it, and one scoped run at that commit is enough to clear it on the next attempt. A receipt that carries no verdict list at all is not read as a failure: that means the mint could not read the run record, not that the checks did not run. A repository that predates the gate tooling is never held on it — when the base carries no landing-proof sentinel, no run at any commit could ever produce such a verdict, so the same pre-cutover exemption that stands the gate-proof standard down stands this rule down too. Without that, a stamped branch in an outside repo waited for a verdict that could not exist and its finished work never landed.

Checks block at tagging, never at landing: the auto-lander lands a branch that carries a ready tag even when that stamp records an owed check absent, because the tagging door is the one place that question is asked. A land-time refusal for an absent stamp is a lander bug. A verdict the stamp records as failed is still judged, by the gate-proof arms.

What it is

The Auto-lander dashboard is one place to watch — and lightly control — the auto-lander, the background service that automatically merges branches you've marked ready-to-merge into their main branch, locally, while Omniscio is open (it only ever moves forward and never pushes to a remote). It lives in the Dev Pipeline panel as the Auto-lander view, opened from the Runs screen, and brings together three things that used to be scattered: the daemon's live status, where each of your branches is and what it is waiting on, and the history of what it has landed, handed back on a conflict, or set aside.

  • Live status — a banner at the top with a coloured dot and a plain-language line for exactly what the auto-lander is doing right now: Starting… in the first moments after the app comes up, then Idle — watching for ready branches, Landing branches…, Waiting on uncommitted changes in a checkout, Stuck — ready branches are not landing, Observing (not armed), or Stopped. It updates by itself the moment the daemon's state changes — no refresh. While Lander V3 does the landing on this computer (it serves every watched repository), the banner reads Lander V3's own queue instead of the retired lander's last pass: Landing branches… with how many branches are queued and the oldest few listed, Idle when nothing is queued, or Unknown when Lander V3's queue cannot be read — it no longer sits on Starting… for good. GET /auto-lander/status serves the same reading, with each queued branch listed as "Queued for Lander V3" (up to 8).

  • Where your branches are — the answer to "where is my branch, and what is it waiting on", grouped by repository. Each watched repo is a card showing whether it's Watching or Paused, and under it one row per branch giving four things in plain English:

    • Where it is — Next to be merged · In line to merge · 2 of 5 · Merging now · Held up · Handed back to you · Set aside — it needs a person · Waiting for a gate answer (or Waiting for a gate to run · 2 of 5 in line) · Couldn't auto-land — it needs you · Held — it needs you · Being handed over again · Set aside by the crew. The last several are not faults the machine can clear by retrying: each names a wait where something is expected of you, of a gate, or of the app's own hand-over, and the row's own "what it is waiting on" sentence says which.
    • What it is waiting on — one sentence, in the auto-lander's own words (e.g. "new commits landed after it was tagged"). Never a code you have to look up. "Tagged" means marked ready-to-merge — a note the app writes on the branch itself, bound to the exact commit that was verified, so a branch that gains commits afterwards is no longer "ready" for that commit (git-guardrails.md gives the marker's rules). You are not expected to redo that by hand: when a branch you marked ready gains commits or is rebased onto newer work, the auto-lander re-checks and re-tags it for you, and only tells you if that automatic pass genuinely cannot land it (dev-pipeline-panel.md). That card lists each affected branch with the commit its ready tag was written for beside the commit the branch is at now, so you can mark it ready again at its current tip. That pass can also retire the branch: when it proves there is nothing left to land — the branch already landed, or its work reached the main branch another way — it deletes the branch through the app's delete door, which writes the branch's tip to an undo ref under refs/amc/approved-branch-retire/ before the delete, and it finishes without reporting. So a ready branch can leave this list with no card, and nothing is lost: the tip is an undo copy you can restore from, and it is copied into a verified archive bundle before that ref is retired. The ref is not kept forever — it goes once its tip is on your main branch or once the branch it was minted for is gone — so restore from it while it is there, and treat the archive as the lasting copy (git-guardrails.md).
    • How long it has been there, and whether that's normal — "12m · about the usual wait", "1h 15m · longer than usual", "3h 20m · much longer than usual". The comparison is against the real measured wait, not a guess: half of all branches merge inside about 15 minutes and three quarters inside 45.
    • Whether anything is needed from you — every row says either Needs you or Nothing needed from you, and the line above the list totals it up ("nothing needs you — these are being handled automatically", or "2 of 7 need you"). Branches that need you are always at the top, and each of them carries the way to act on it: Go to session jumps to the session that owns the branch where one is known, and Open in project opens the repo's project where none survives. A row is never a dead end you then have to hunt for in the sidebar. A branch Needs you is also left alone by the lander: once it has decided a person owns the wait, it stops spending passes retrying it, so the branches behind it are still merged and the queue does not keep saying the lander "ran out of turns" about work only you can unblock. The branch keeps its ready tag and is tried again the moment the wait clears — a re-tag, a sign-off, or new commits on it.

    A row only appears while its branch still exists. A hand-back is a statement about a branch, so once that branch is gone — deleted after an abandoned re-attempt, or merged by something that never recorded the merge — there is nothing left for you to act on and the row retires itself. This is why the count can be lower than a list you saw earlier: it tracks live work, not history. A hand-back also stops reporting 24 hours after it happened, even if the branch is still sitting there — past a day it is history, not live work, and the same 24-hour window drops it from the session's own land status strip.

    Above the list it says how old the reading is ("as of 3 minutes ago") — so you never mistake a stale answer for a live one. A repo with nothing waiting says so, and an empty list explains how a branch gets here (mark it ready-to-merge); a repo whose branches couldn't be read says that instead, in the recorded reason's own words — a timeout that clears itself, or a project that no longer points at a folder and needs fixing — rather than pretending the queue is clear. A paused repo is not blank: it keeps its Paused pill and still lists what is waiting on a person, with one line saying nothing there is merged automatically. If the reading itself fails, the section says it couldn't load and offers Retry instead of spinning. If you have no repositories set up yet, it points you to the Setup tab.

    This replaced the older Ready & waiting to land list, which showed only branch names and ages: there is one branch list here, never two that could disagree.

  • Recent activity — the land history. Each row shows the branch, its repo, the outcome (Landed, Conflict, Refused to land, Couldn't land, or Waiting its turn — a branch the lander set aside instead of landing, e.g. blocked from landing, gave up after retries, or already-merged, with the reason), and when. Waiting its turn is the ONE row that is not a verdict: the hang guard stopped that attempt — it had run past its four-minute attempt bound with no progress for two of those minutes — so nothing moved, the branch is still tagged ready, and it is retried on a later pass. It never replaces the branch's real outcome — a branch that conflicted and was then killed still reads Conflict, and every kill gets its own row so a long stretch of nothing landing is visible here instead of only in a log. Refused to land is a deliberate refusal — the lander declined to land the branch and said why (a safety check held it, the branch changes a dependency, its new text is not translated yet); it is NOT a merge conflict, and it shows no conflict detail. Click a row to expand it: a landed branch shows the detail (e.g. how many commits) and the new base commit, plus a Go to session button that jumps you to the session that produced the branch; a conflict shows what it conflicted against and the exact files, so you can see which subsystem is stuck. A branch that conflicts again after its author pushes new work gets a fresh Conflict row, while the same conflict re-checked on a later cycle is listed once. A conflict confined to help pages and memory notes lands instead. When every file a branch disagrees on is a hand-written document — a page under the help library, or a note under the memory folder — the lander keeps BOTH versions: master's and the branch's, side by side in the same file, with no conflict markers. The land's detail names each document it kept both ways, so open it and tidy the doubled text whenever you like. Anything else still hands the branch back: a conflict touching code, config or a generated index, a deleted document, and every contract, because two versions of one rule is not something a machine should pick between. Older landed rows show no new base commit — it was not recorded until late September 2026 — and neither does a branch someone landed by hand, unless the lander could check that commit itself.

Where to find it

Open the Dev Pipeline panel from the sidebar, then pick Runs on the left rail (the rail has three destinations — Runs · Stages · Setup) and click the What the auto-lander is doing line under the runs list; that opens the Auto-lander view. The same Runs screen carries an Agent board line when the Agent Status Board is switched on (off by default), and the Stages screen carries the QA fleet line. The Dev Pipeline panel has SHIPPED (status: 'shipped') — it is visible to everyone, with nothing to enable first. The view works on the phone / Web Access too, like the rest of the panel.

Quick actions.

  • Pause / resume the whole auto-lander — the button in the status banner. Resuming asks you to confirm, and says plainly what turning it on does: from then on every branch you mark ready-to-merge is merged into your main branch on its own, with no further review step. Pausing is one click — it only stops landing, keeps your watched repositories, and is undone by turning it back on. This is the same on/off switch as the Auto-lander card in Setup → All settings and in Settings → PR Merge Queue (under Automations & Rules) — flip it in either place and both agree.
  • Pause / resume one repository — the button on each repo's card. Pausing a repo leaves it configured but stops the auto-lander from landing its branches; it stays visible (as Paused) so you can resume it. A paused repo simply drops out of the queue. Resuming one repo confirms too, naming that repository.

The confirmation sits on the arming direction on purpose — pausing is reversible and loses nothing, while arming puts unreviewed code on your main branch. The Auto-lander card's own master switch in Setup → All settings follows the same rule.

Only the main computer lands work. On any computer that is not marked as the main one, the auto-lander is always off: the Setup switch is greyed out, the status banner has no Pause/Resume button, and both say "Only the main computer lands work. This computer sends finished work to GitHub as pull requests." A command-line request to switch it on there is refused with the same reason, and no approval card is raised. Finished work on those computers goes to GitHub with npm run pr -- --push, and comes back through the normal master sync.

On the main computer's fresh setup there is usually nothing to arm. The lander turns on with the Dev Pipeline itself — switching that on is the whole setup step — so the click most people make here first is Pause, not Resuming. Nothing is written into your settings on your behalf: that default is derived, and it holds until the day you choose either way.

From the command line they have two dedicated routes of their own, and those are the ones to use. They name the lander's own state rather than a settings key, which is why they are the shape a script's receipt and a person's approval are read from — and they are the road the optional pause reason below is written through:

PATCH http://127.0.0.1:19519/auto-lander/arming            {"enabled": false}   # the master switch
PATCH http://127.0.0.1:19519/auto-lander/repos/<projectId> {"enabled": false}   # one repo

The general PATCH /settings/:key route is not closed to these two keys: turning the lander on through it is held for the owner's approval, while turning it off is never gated and takes effect at once, because pausing only ever tightens. The dedicated routes are the clear way in, not the only one.

A pause can record why it happened. When a rebuild or a restart procedure disarms the lander, it can record the pause as its own state — who asked, why, and until when — and the app switches the lander back on by itself when that window ends, so a lapsed pause never leaves landing off. Pausing from the dashboard clears any such record, so its expiry cannot re-arm over your pause. A lander that is merely off with no such record is not refused — it lands as it always did.

A CLI pause is a lease, even when it declares nothing. {"enabled": false} with no freeze used to store no record at all, so a session that paused the lander from a script and never re-armed it left landing off with nothing naming who had done it or why. That call is now written as a lease: the calling session (or cron job) is recorded as the holder, the reason says plainly that none was declared, and the window is the lander pause expiry — two minutes — which is also the default a declared pause gets when it leaves until out; after that the app arms the lander again by itself. While a lease from this route is live and finished branches are waiting, the inbox card is raised after five minutes (a plain disarm that carries no record is watched at thirty), naming the holder, the reason and when it re-arms. A pause that does declare a freeze keeps its own window — a rebuild that needs longer says so — but it is watched at five minutes too, because this road has no dashboard caller and a declared pause nobody is told about is the same silence with a longer deadline. That five minutes belongs to this route: the landing freeze npm run lander:switch writes is a different record and is carded only after thirty minutes — Landing freezes covers that one. The dashboard's own toggle is unchanged, and still clears any record so its expiry cannot re-arm over your pause.

What stays in the panel's settings. The heavier configuration — adding or removing repositories, choosing a repo's integration branch, observe-only (dry-run) — lives in the Dev Pipeline panel under Setup → All settings, not in this view; Dev Pipeline panel documents those controls. The Auto-lander view is read-mostly monitoring plus the two pause toggles; it deliberately doesn't re-implement the config editor. This split keeps the pipeline's controls one click in, in the panel's own settings (a panel rule), while the monitoring gets its own home.

QA Fleet (on the Stages screen). The Stages destination carries a QA fleet line that opens the QA results view, and it is the only one of these lines with no gate — it is there for everyone. It surfaces the ledger Omniscio's own background QA runs write, so the app's own test coverage is something you can look at rather than take on faith. It shows per-feature end-to-end pass/fail, a ranking of the features that have gone longest without being exercised, and a findings trend over time. The open findings are triaged from right there — resolve, dismiss, or reopen — and closing one offers a one-click undo, so a mis-click costs nothing. The line carries an amber count whenever findings are open, and it refreshes every 30 seconds on its own.

How it behaves

How it works, briefly. The queue reuses the auto-lander's latest process-local observation instead of launching another Git scan whenever the screen reads it. Marking a worktree ready updates that observation and the session's queue position immediately; once shown, the queue notice remains visible until the durable auto-landed message is available to replace it. A failed display update falls back to the next canonical supervisor scan, and Git remains authoritative. The Next to be merged row reflects the daemon's own selection order (a soft hint — the live per-attempt backoff isn't shown). When the machine is busy, the daemon lands in bounded batches and spreads its attention fairly across your watched repos: each landing cycle is capped to a fixed time budget, and any repo the cycle couldn't get to goes first on the next one — so a repo late in your list can't sit unlanded behind busier ones, and no cycle can run long enough to pile up on itself.

Pausing a session holds its branch (2026-11-09). When you pause a session — one at a time, or many at once — the auto-lander will not land that session's ready branch, and no rescue session starts for it, until you resume the session. This also covers a branch a rescue session had already taken over before your pause, and a session the app had paused before you selected it and pressed Pause. A held branch is not counted as waiting or stuck. Resume the session (or archive it) and the branch lands on the next pass. Asking the auto-lander to land a branch by hand still lands it.

Every count on the widget is work you can still act on (2026-11-04). The Waiting to land number, the oldest wait beside it and the Stuck number used to count rows rather than work, and the owner read 84 waiting when only about eleven really were. Three things were wrong and each is now measured against the thing itself (the second and third bullets below came the next day):

  • A branch that already landed leaves the queue. A landing merge keeps the branch's commit on your main branch while the branch's "ready to merge" description stays behind, so the row could sit there for as long as its branch did. A row is now dropped when its exact tagged commit has a land record naming it, or when Git proves that commit is already reachable from the main branch. It is not hidden — it moves into the branch list's "already landed" note, so the number falls and you can still see what happened to it. A branch you re-tag at a NEW commit after it landed comes back, because that new work has not landed.
  • It still leaves when Lander V3 is the one landing (2026-11-05). While Lander V3 owns master, the old lander stands down and its scan — the step that used to drop landed rows — never runs, so the queue only grew: on 11-05 at 3:52 AM, 18 of 20 rows were already on master. Now the queue, the waiting count and the crew's oldest-ready reading first check the rows they hold against the main branch, the same land-record and "reachable from the main branch" test as above, and take off every row that already landed, by any road (a V3 train, an owner-ready land, a catch-up). It is one batched Git read per repository, only when the main branch or the row list changed, at most once every 15 seconds, and a reader waits at most 5 seconds for it. The lander's own tick runs the same check about once a minute, so screens nobody has open stay right too. A row re-tagged at a new commit, a main branch that cannot be read, or a failed read keeps the row.
  • Who is landing is said plainly. While Lander V3 owns master, each queue row for a repository V3 serves carries mover: "lander-v3", and its note says V3 owns master instead of "the auto-lander has not run yet". GET /auto-lander/status carries mover — engine is lander-v3, auto-lander, or unknown when the claim on master cannot be read — with a sentence saying this lander lands nothing and to read GET /lander-v3/status. running and armed keep their old meaning (the process is up, the switch is on), so read mover, not running, to learn who moves master.
  • A hand-back only counts while it is live. A conflict or "couldn't land" hand-back used to count for up to a day, long after its branch was deleted, moved on, or landed. It counts now only while the branch still exists and still sits at the commit that was handed back — and it stops counting once that branch is known to have landed.
  • Another project's branches are not your queue. The counts describe the repository the app is running from. Other projects' branches still have their own rows and their own worktrees, but they are no longer added to this repository's waiting, oldest-wait, stuck or foreign-work numbers. The worktree numbers beside them stay box-wide on purpose: those are checkouts, not a queue.
  • The waiting number is the queue land:now would drain (2026-11-08). It came from the old lander's in-memory observation of its queue, and that store is only published by the classic land pass and its under-load triage — both of which stand down while Lander V3 owns landing. So it held nothing but the branches stamped through this app since it started: on 2026-11-08 at 10:34 AM it read 6 waiting, oldest 41m while 89 branches carried a ready stamp at their own tip and were not on master, the oldest of them by far more than an hour. The waiting count and the oldest wait are now read from the repository itself with the same rule scripts/land-now.mjs --all-ready applies — a stamp that says ready, that names the branch's CURRENT tip, and whose commit is not already on your main branch — so the widget and the lander's own --all-ready queue agree by construction. The age is that branch's real wait: when it FIRST went ready, so re-stamping a branch no longer resets its clock. It is computed per repository at most once a minute, nothing is scanned while no screen is open, and the number stays a dash until the first reading lands. Held branches still count as waiting, exactly as they do for land:now, which attempts them and skips them itself; the Stuck line is where the ones that need a fix are named.

How long the stuck pile has waited, and every branch in it (2026-11-19). The sidebar's Waiting to land card now says how long the stuck branches have been stuck — the median and the oldest — and carries a See all N stuck branches link straight to a Stuck branches list on this screen. The list names every stuck branch, why it stopped, how long ago, and offers Go to session when an owner session is recorded. A read that fails says so; it never renders an empty list.

A stuck conflict nobody owns gets a cloud fixer (2026-11-12). When the lander hands back a branch that clashes with the main branch and no live session owns it, the branch is parked with a note for a crew lead. If that note has sat for 30 minutes and the branch has not moved, the app now starts one cheap cloud worker to merge the main branch into it and bring it home; the branch then lands on its own. It tries a given commit at most twice, waits 3 hours before a second try, never starts a fixer on your own computer, and stops entirely with AMC_DISABLE_OWNERLESS_CONFLICT_RESCUE=1.

Right after the app starts, Waiting and Stuck show a dash rather than a number, because nothing has been read yet — the dash means "not known", and it is never drawn as a zero. Every one of these checks gives up in the safe direction: if the main branch cannot be read, a Git read fails or the record is unavailable, the rows stay counted and the landing itself is untouched. The lander still sees the full list, so none of this changes what gets merged.

A repo the lander never started names itself on the status line too (2026-10-29). A repo the pass skipped wholesale contributes no ready count, so neither the "stuck" nor the "stalled" wording can fire for it and the status used to fall back to the bare counters — "landed 0 this sweep, deferred 0" under an Idle label, while sixteen ready branches waited behind a catch-up, a main folder that had not followed, a sync that had not kept up, a merge already running, a spent time budget or a cycle that threw. The status detail now names every repo it skipped that way, in the same words the skip uses elsewhere, and keeps the health refusal's own pointer to its inbox card. A dormant repo (idle-unchanged) and one the lander is switched off for are not named: there is nothing wrong in either.

The note is one segment of a composite clamped to 512 characters, so its order carries meaning: the health refusal's pointer to its inbox card comes BEFORE that refusal's tally, because the pointer is the actionable half and a clamp that cut it would keep only the counts. The held-repo sentence is a second segment, appended after it, for the same reason.

What the queue counts. The queue lists branches that are tagged ready to merge and still exist. A finished branch can keep its tag after its work has landed and the branch itself has been deleted — the "landed" record and the branch cleanup can both lose the race for the stored branch description — so the queue leaves such a branch out instead of showing work that can never land. The number it left out is carried as landedLeftBehind on each repo's row in GET /auto-lander/queue (0 when nothing was left out), the app logs the branch names once, and the leftover tag itself is cleaned up by the hourly housekeeping pass. A branch tagged only moments ago is always shown, even if git has not listed it yet.

Why a queued branch is not landing. Each branch in GET /auto-lander/queue also carries waitingOn — the plain reason the lander is holding it right now, or null when nothing is. The branch-life readout prefers the same sentence, so the two cannot disagree about a branch that has a wait. A branch the batch lane keeps setting aside (for example because its change to a file is not in the combined landing tree it built) shows that reason here instead of reading as an ordinary entry in line. waitingOn can only describe a branch the lander has already TRIED; a branch the pass never reached has none, and both surfaces fall back to that pass's own notAttempted sentence for it (next paragraph), so not landing never reads as nothing wrong on either surface.

A branch the pass has not reached yet says so (2026-10-26). waitingOn can only describe a branch the lander has already TRIED — its answer comes from what each attempt left behind. A branch that has been skipped, every pass, before the lander ever got to it therefore used to read as an ordinary queued entry with nothing wrong, which is exactly how a starved branch hid for hours while others landed around it. Each branch row now also carries notAttempted — { cause, reason, atMs } — whenever the last pass did not attempt it: cause names the bound in the lander's own vocabulary (a spent time budget, the box-wide attempt cap, another branch's rework hold, a paused project because master does not build, and so on), reason is the same fact as a plain sentence, and atMs is when that pass ran. The key is absent — not null — when the pass did reach the branch, so a skipped branch and a healthy one are now different rows. It is tied to the commit the branch is on: re-tag it at a new commit and the old skip is not reported, and the pass that finally reaches the branch clears it.

A whole project skipped counts too (2026-10-29, Help Desk #1570). Before this, notAttempted covered only the case where the pass considered a branch and deferred it. A repo the tick skipped WHOLESALE — master sync not keeping up, a main folder that has not followed, a catch-up levelling the computer, a merge already running there, a cycle that threw, a folder the health check refused — produced no per-branch record at all, so every branch in it read as an ordinary queued entry with nothing wrong while nothing landed for hours, and the stall card's copy named no cause anyone could act on. Such a skip now records one notAttempted row per branch the last read saw in that repo, cause being the skip's own name and reason the sentence for it ("the lander skipped this project's folder this pass: …"). The lander also logs one line per skipped repo naming how many ready branches it was holding, so the same fact is greppable in main.log. The sentence table lives once, in repo-skip-copy.ts, and the blind-repo card reads the same wording.

A branch the safety check is holding says so. When the safety check that runs before every land refuses a branch, the branch-life list shows it as Held — it needs you, with the check's own reason, even if an older hold (for example a lane lead's) was recorded on the same commit first. The newer, still-current reason always wins; once the branch gets a new commit, the old hold stops counting. Held means the lander is still sitting on the branch right now — the check's refusal is a record that is kept for good, so the row asks the lander's own live answer for whether the hold still stands rather than trusting the record, and a hold the lander has since released goes back to showing the branch's ordinary state. A branch that reads Held there is one the lander is genuinely not retrying.

A branch waiting on a half-finished git operation stops waiting once that operation is gone (2026-11-11). When the lander puts a branch aside because another merge, rebase or cherry-pick is running in the repository's folder, it keeps that as the branch's reason — and if it stays that way the branch is handed to you, which used to mean it stayed yours until a person intervened. The folder is now re-checked on every pass, so the moment the leftover operation is finished or cancelled the branch goes back to the lander on its own and its row says the land will be retried on the next pass, instead of naming an operation that is no longer running. Nothing is handed back on a read that did not happen: if the check cannot answer for that folder, the branch keeps the state it has. A branch whose wait was already a recorded give-up is never taken back this way.

A hold leaves a record in the history (2026-10-15). Each time the safety check holds a branch and the lander really takes the hold, the auto-lander's history gets one entry for it, in the same plain words the Held — it needs you row uses: why the check refused and what ends the hold. A branch the lander keeps retrying writes nothing, and the same hold is never written twice. A batch of branches refused for adding a pattern an always-on check bans is now split until the one branch that caused it is held on its own, instead of holding every branch in the batch.

Branches already on your main branch are retired quietly (2026-10-14). If a branch is stuck on the safety check but its work has already reached your main branch, the lander no longer raises a card about it. It saves the branch's last commit, takes the ready marker off and retires the working folder, so nothing is lost and nothing needs you. Only a branch the lander can prove is already on main is treated this way; if it cannot prove that, the branch is carded as before.

Several branches can land in one move (batch landing, on by default). When more than one branch in the same repository is ready, the daemon checks each one exactly as it always has — every guard, veto and scan — and then merges the ones that fit onto your main branch together, in a single move, instead of one at a time. Each branch still gets its own merge commit, its own "landed" record and its own notice to the session that made it, so nothing about a batch shows up as a batch: the queue, the history and the inbox all count branches, never moves. A branch whose tag changed while it waited, or whose files collide with a sibling's, simply drops out of that move with the same outcome it would have had on its own, and is picked up again next cycle. A busy machine automatically lands fewer branches per move. To go back to one branch per move, set autoLanderBatchLandingEnabled to false with PATCH /settings/autoLanderBatchLandingEnabled — there is no control for it in the panel or in Settings, because it is a diagnostic lever rather than a day-to-day preference.

That switch governs the daemon's own choice of what to batch, not an explicit request to land several branches together. A hand-land may name a whole GROUP of branches in one request, and those are landed as a single move even on a machine where autoLanderBatchLandingEnabled is false — the request is asking for one move, so turning off the daemon's batching does not silently turn that request back into several. Group members are checked exactly as any branch is, one at a time, and the request is refused whole if any of its branches is not landable at the moment it is asked for; once it is under way each branch answers for itself, so one branch that cannot make the move is reported on its own and does not take the rest down with it. A group request may not stand a check down: those are for a single urgent branch, and a group runs the full chain.

Hand-land requests take turns. Each pass lands at most one queued hand-land request before its ordinary queue. Urgent requests go ahead of ordinary ones but are served in the order they were asked — asking again does not jump the line — and a request whose branch cannot be tried right now (backed off, or held by a check) goes to the back of its line so it cannot block the requests behind it. It stays queued and comes round again. Inside the ordinary queue, a branch the lander already tried and refused keeps that history for a day, so it waits behind finished branches that have never been tried instead of jumping back to the front by the age of its tag.

Why one branch can sit still while others in the same repo land. That fairness is between repos; inside one repo each branch carries its own hold, and its row always names it — waiting on you, parked behind a safety check, handed back on a conflict, or simply losing its retry race to the branches that landed ahead of it. A branch being passed over is therefore not by itself a broken lander, and that row is the thing to read. It is a known failure class rather than a normal state of affairs, though — a branch that could only ever lose the race, or whose "ready" marker outlived the commit it was bound to, has stranded there before and been fixed — so if a branch is genuinely stuck while its neighbours keep landing, say so rather than waiting it out.

A computer whose auto-lander is off does not keep asking for gates on a branch's behalf. The "parked ready" follow-up (the part that re-sends a gate nobody answered and tags the branch ready once it passes) only runs while the auto-lander is armed, because the ready tag is read by the lander and by nothing else that matters on that computer. While it is off, a parked branch is simply kept, no gate is re-sent and no ready tag is added for you; mint it by hand when you want one, and the follow-up resumes on its own the moment the lander is armed again. Separately, whichever way the lander is set, a gate that is already queued for a branch's code is reused rather than asked for again, so an unanswered gate no longer piles up copies of itself in the check queue.

When a branch needs a person and its author is gone. If a branch hits a conflict, a safety check it can't clear, or a failed check, and the session that wrote it has ended, the lander raises an inbox card — "A branch needs a fix and there is nobody left to do it" (developer-only — dropped on an installed build; see Which auto-lander events reach your inbox on part 2). That card takes itself down as soon as it stops being true: another session is actively working the branch, it is marked ready again, it lands, or the branch is gone — so a stale card can't send a second session into a folder someone is already working in. It stays up while the only session on the branch is paused or finished. (On a machine with plain, non-git folders registered as projects, one unreadable folder used to keep every card up; it now looks only in the repos the lander lands into, so a landed branch's card comes down on the next sweep.) The card also comes down when someone took the branch out of the queue on purpose — its own session blocked it, a rescue branch that carries its work blocked it, or it was marked superseded because its work already reached master another way. A block by a rescue counts only while that rescue has landed or is still marked ready to land; if the rescue was dropped or sent back, the card stays up so the work isn't lost.

A conflicting branch nobody owns is fixed automatically, not carded (2026-10-16). When a branch conflicts with master and its author is gone — or no session owns it at all — the lander no longer raises the "nobody left" card. It hands the branch to its own rescue: about 30 minutes later a repair session merges master in, resolves the conflict, re-checks and re-marks the branch, and it lands. A branch that has no working folder of its own (a batch branch whose folder moved on, for example) gets one leased for it first, in the background. You hear about it only if the rescue can't act: the rescue is switched off, or three tries fail, in which case the branch is set aside quietly onto the daily complete-or-drop list. The card still appears when the rescue or its sweep is switched off (two operator switches, off by default, turn the rescue and its sweep off), and cloud branches keep their own routing.

A merge you asked for comes back to you (2026-11-07). When a session asks for a branch to be merged by hand — an owner override, say — and that branch conflicts while no session owns it, the conflict now goes to the session that asked, as long as it is still running or waiting on you. It gets a short note saying what conflicted and what to do; no "nobody left" card is raised and no repair session is started. If the asking session has ended, the usual road above runs. Separately, a hand merge of a pull request that a newer open pull request by the same author says it replaces is refused and names the newer one, and the pull-request merging queue lists such requests as replaced instead of picking them up.

A stuck branch whose author is gone is rebuilt automatically (2026-10-14). When the safety check is holding a branch because it could not finish checking it, and nobody is left to deal with it, the lander no longer goes straight to a card. It starts a repair session that rebuilds the branch as a clean straight line of its own commits on a new branch and sends that through the normal tagging and landing road. The original branch is never touched, and it retires quietly once the rebuilt one lands. Each branch gets up to three attempts, at most four such repairs run at once, and one waits its turn while the machine is busy; a branch waiting its turn stays off the card. If the attempts run out, the card comes back, as it always did. The card, when it does appear, now says that the automatic rescue could not take the branch on. Operator switches (off by default) turn the quiet retiring and the rescue off.

Refused branches get a narrower rebuild, and no branch needs its own folder to be rescued (2026-10-16). A branch the check REFUSED, because a merge inside it would drop or rewrite work already on main, is now rebuilt too when its author is gone, but more carefully: the repair copies only the branch's own commits onto a new branch, stops at the first conflict, and never brings back anything the refused merge did. It only does this for refusal reasons where that rebuild is the documented fix; any other reason still comes to a person. Rescues also now work in a fresh folder of their own, so branches that never had a folder (batch-land branches and branches that came back from cloud sessions) are no longer turned away, and cloud branches are no longer left to a road that just retries the same refused commit. A rescue only counts as running once a real session has started on it. Once the rebuilt copy has landed, the original branch retires by itself. An operator switch (off by default) turns the refused-branch rebuild off.

Splitting a big file no longer gets a branch stuck (2026-10-17). When a branch moves a block of code out of one file into a new one, and main edits that same block in the meantime, the branch can now merge main in: the check counts main's edits as kept once they are carried into the file the block moved to, in the merge itself or in a later commit. It still refuses when main's edits were carried nowhere, when only a handful of lines moved, or when the merge also deletes other lines from the new file.

A returned cloud branch that deliberately removes recent main code can be cleared without you (2026-10-17). When such a branch's own session is gone, the lander first merges main into it whenever any flagged file changed on main, then its rescue judges the removal and can approve it, and that approval now counts at landing. The rescue never touches a branch someone marked blocked or superseded. This road runs only while the "returned dropped-work rescue" setting is on; it ships off.

The "held, drop approval unproven" card follows the check and clears itself (2026-10-17). The card is raised only while the dropped-work check is actually blocking the branch: under an advisory, measured or off mode the lander still records what it saw and logs it, but no card is raised. When the hold ends — the check passes, the drop is approved, a carried approval lets the branch land, or the check stops blocking — the card goes away on its own instead of sitting in the inbox for you to dismiss. A branch's approval also reads correctly now when the branch has both a returned-branch record and a working folder on this computer.

A branch whose work already landed another way is retired, even on a busy machine (2026-10-16). A ready branch that sits on main with nothing of its own is retired right away instead of waiting for a quiet moment. One that was reset onto main while its own work landed through a sibling branch is also retired, but only when every file it changed already reads the way main has it and none of its folders holds unsaved changes; otherwise it stays put, as before. An operator switch (off by default) turns that retiring off.

A branch is never retired on evidence measured at a commit it has already left (2026-11-02). The lander only retires a branch when the thing it proved is true of the branch's current commit — either the land it is acting on was proved at that exact commit, or git itself confirms the current commit is already on main. When neither holds, or when that question cannot be answered, the branch is left exactly as it is and asked again shortly; it is not reported as a problem for you to fix, because there is nothing for you to do. This closes a real loss: on 2026-11-02 a branch one commit ahead of main was retired as "already in master" because the proof had been counted at the commit it started from, and its ready tag was replaced with a "landed" note. A branch wrongly kept costs one more attempt; a branch wrongly retired costs the work, so this check only ever holds a branch back.

A wrong "landed" note can be cleared once git disproves it. Because that note is pinned to the commit it was written for, a branch carrying a false one can never be re-tagged by itself. When the lander's own proof positively shows the branch still has commits main does not, POST /worktrees/:id/landed-record/clear removes the note so the branch can be tagged ready again. It refuses on anything less than that — a branch that really did land, or a proof that could not be read, leaves the note in place.

A waiting branch no longer tells you "it will finish by itself" once it needs you (2026-10-26). When a branch's last land ran slowly and the lander is not retrying it right now, its row says exactly that — "its last land attempt ran slowly and the lander moved on to let it finish by itself" — and the row stays Nothing needed from you. That sentence only holds while the lander still owns the wait. Once the branch has waited a full stuck window (about an hour), or the lander has recorded giving up on it and a person has to act, the row shows that real reason instead ("it keeps being deferred without landing… so it needs a look", or the recorded cause) and switches to Needs you. The same goes for a reason a re-check or a fresh refusal has replaced.

A cloud branch waits for its own author to finish the conflict it is already fixing (2026-10-25). When a branch that came back from a cloud session conflicts with main, the lander rents a resolver machine for it — but not while the session that wrote the branch is still alive and repairing that same conflict itself. "Repairing" means it asked for main in the last hour through the catch-up step the ready check points it at, or its machine still had that merge open the last time the app looked. In that window the branch is left alone and nothing is rented; once the author is gone, or an hour has passed, the resolver machine is rented exactly as before. This stops one conflict from costing two machines and putting two agents on one branch.

Closing a session doesn't stop it fixing its own conflict (2026-09-25). When a branch conflicts, the lander wakes the session that wrote it to rebase and re-mark it — and that now includes a session you closed after reading its report, because its unfinished branch is still its own to land. A session you paused is left alone, and the "nobody left" card above is what you get then. Branches the lander refused for a mass deletion are not conflicts, so a closed author is not reopened for those — you get the card. Waking an author that has ended, or reopening one you closed, is a new turn on that session — a billed turn, spending your account's usage for the work it does, and the lander issues it without asking you first. If you would rather a session you closed stay closed, an operator switch (off by default) stops the reopen; with it on the lander will not reopen a session you closed, and the branch takes the "nobody left" card instead.

What counts as a mass deletion (and how to approve one). Before every land the lander refuses a branch that would destroy too much of the tree — deleting all tracked files, more than half of them, or more than 50 files while editing ten times fewer — or that blanks a tracked file to zero bytes. That catches the shape where a checkout is not really populated or a cleanup went wrong, not a real refactor. If a large deletion is genuinely what you meant, clear it yourself by putting a Mass-deletion-approved: <why> trailer on a commit in the branch (the reason is free text); the lander honours that sign-off and lands the branch. A returned cloud/* branch has no worktree to commit in, so its launcher approves it instead through POST /worktrees/:id/approve-dropped-work with "kind":"mass-deletion" — without that kind the approval is recorded for a different check and the branch stays refused.

When the same conflict comes back three times, the lander stops the ping-pong (escalated self-land). A conflicting branch is handed back for a rebase; if it conflicts again after being re-marked, that hand-back is counted. On the third hand-back for one branch the lander stops retrying: it puts a short exclusive hold on the repository — for about five minutes no other branch in that repo lands and your main branch stands still — reopens and surfaces the session that wrote the branch (one billed resume), and tells it to rebase onto the now-stationary main branch and re-mark the branch. A stationary base is what makes the rework land in one attempt instead of re-conflicting forever. If the branch lands inside the window the hold clears at once; if it cannot, the hold expires on its own, normal landing resumes, and the branch is handed to you to merge by hand. This is why a branch occasionally stops landing while its neighbours do — the repo is briefly frozen behind a three-strike escalation, not broken.

Start session on it opens an agent that first claims the branch's folder through the app, and stops without changing anything if another session is working there. And a session whose folder is taken over by another one is told so — which folder, which branch, who has it now — the next time it starts, or straight away if it is still running.

A session you start from a lander card counts as working that card's branches (2026-09-24). When you click Start session on one of these cards, the auto-lander treats that session as working the branches the card handed it:

  • the "need a hand to finish landing" card;
  • the "blocked from landing" card;
  • the "review to close" card;
  • the parked-branches card (its "nobody is working on" rows only).

While that session is open, those branches don't come back on another card, and the auto-lander doesn't start a rescue session of its own on them. This holds even if the session never makes a working folder. Once the session ends or you archive it, the auto-lander handles those branches as usual again.

A branch with no folder of its own is only "being worked on" by a session tied to it (2026-10-31). Many parked branches have no folder: every cloud capture, and any branch whose folder was cleaned up. For those, the parked-branches card and the auto-lander count only three things as someone working on it: the live session that built it, a live session that has that branch checked out, or the auto-lander's own rescue for it. Sessions that simply happen to be working in the main project folder no longer count. Before this, the card could say "held by a live session" about branches whose session had long been archived, and the auto-lander never started a rescue for them. Now those rows read "nobody is working on" and the card offers Start session.

The view refreshes itself while it's open (on the daemon's status push, plus a light timer that catches a branch you tag while the daemon is idle) and costs nothing when the view is closed. Pausing never interrupts a land already in progress — the setting is read on the next cycle, so an in-flight merge finishes safely first.

After a land, your main project folder can show changes you did not make — that is expected, and it is not work. A land moves your main branch by pointing it at the new commit, and the folder you keep open next to it is brought up to date right afterwards — that follow-up is routine, so it is silent (part 2 has the detail, including the one exception). Until it happens, that folder's index and working tree sit at an older commit while its HEAD races ahead, so git status there reports every path those lands touched as a change — a set that grows with each land. Nothing was staged, nothing is unsaved, and every byte of it is already committed. Do not clear it with a reset or a discard — that is the one genuinely destructive response, and it is aimed at the wrong folder anyway. To clear it, bring that folder up to date with its branch.

When a file a change added really is missing from that folder (since 2026-10-03). Rare, and worth knowing how to read, because it is the one case in this area where the folder is genuinely short something. A change lands by moving your branch pointer; the files follow separately. If that follow-up cannot be applied — most often because an app is running from the folder and rewriting compiled source under it would restart it — you get one inbox card naming the files that are still absent. The hourly folder check retries by itself, and starting the app from that folder puts them back; while an app is running from the folder, the source files it is running from are deliberately held back, so a card naming one is expected to outlast one app session. The card is not a drift report and not a call to act: nothing is staged, nothing is unsaved, and it clears itself the moment the files arrive. If the number it gives looks far larger than what you would expect, say so — an earlier version of this check read the wrong side of git and named every file the folder was merely behind on, rather than the ones actually missing.

When the git index is lying. A repository's multi-pack-index can end up pointing at a temporary pack file that a slow fetch is still writing; git then reports objects that exist as unreadable. The auto-lander now re-runs such a read with that index switched off, keeps landing, and raises one card — "Auto-lander: the git pack index is poisoned — landing continues with it switched off" (developer-only — dropped on an installed build; see Which auto-lander events reach your inbox on part 2) — that clears itself once the faults have been quiet for half an hour. Nothing is missing and nothing needs you unless the card keeps coming back for more than an hour, which means the fetch that owns the temp pack is stuck. And a branch that has gone stale-and-conflicting is handed back to its author session to rebase and re-mark ready — found by the session id stamped in the branch description, and reopened even when you closed it after reading its report, because its unfinished branch is still its own to land. That is the usual road rather than the only one: a paused author is left alone, a session whose folder someone else has taken over is not woken, a cloud author is never woken (the app starts a resolution on a cloud machine of its own instead, and tells you when it cannot), and where no author can be reached the branch is set aside — handed to the automatic rescue when there is truly nobody (the "nobody left" card only when that rescue is switched off), and quietly when the author lookup itself failed. So a branch can still sit unlanded with nobody watching it; its row is what tells you. A branch that gained commits after it was marked ready gets the same treatment: its author session is asked, once, to re-check and re-mark it. Since 2026-09-23, re-marking it at its current commit ends the lander's wait on its next check instead of the rest of a backoff that can reach ~18 minutes, so the author is no longer told "commits were added after it was tagged" about a tag it has already fixed, and is not sent the same request again while it is still working on the branch.

Every card the auto-lander raises about a branch is developer-only. The ready backlog piling up, the lander stuck or not landing, the git pack index going bad, finished work that never reached master, the "a branch needs a fix and there is nobody left to do it" card, a branch parked behind a safety check, a branch set aside because it would drop merged work, and the card that arrives when a blocked branch lands with its author's sign-off — all of them are delivered only when Omniscio runs from source: on an installed build each is dropped outright, not merely muted (inbox-alerts.md has the rule). The same holds for the health cards the land watcher raises about the pipeline itself — a branch stuck in the land pipeline, a slow merge gate, runs being turned away, the lander gone quiet — which arrive as one daily line rather than a card each. They report on the lander's own operation rather than on your work. The one card in this area that reaches you on either build is the approval request for a branch that changes a dependency or a lockfile: it asks you to decide something rather than reporting on the lander.

The branches the lander will not land without your approval, the holds that keep already-landed work safe, and what happens to a branch that stays stuck — a queue waiting on you, a check that ran out of time, a branch retried forever, one that would drop merged work, and the machine going first on a stuck branch — are on part 3.

When the drive the lander keeps its working folders on has less free space than your low disk space floor setting, the lander stops writing new full checkouts there. It keeps the folders it already has, lands from the live checkout instead, and the log line says which drive, how much is free and what the floor is. Landing itself carries on; it picks the folders up again once the drive has room.

The rest of this page's behaviour — the catalogue of every reason the lander refuses a branch and the modes you can set, how the merged-tree verify shrank, and what happens to your main folder after a land — is on part 2.

This view belongs to the Dev Pipeline panel, whose other screens and their placement rules are covered in Dev Pipeline panel. The ready marker this dashboard reports on — and what makes a branch landable at all — is set out in Git guardrails, and the inbox cards described above sit alongside the other cards that need an answer in Inbox alerts. The rest of this page’s behaviour — the refusal catalogue and what happens after a land — is on part 2. The branches the lander holds back for your approval, and the holds that keep already-landed work safe, are on part 3. When a branch stays in trouble and the session that owns it has stopped acting, Branch owner escalation covers who becomes answerable for it and how that moves up the rungs.

Last verified 2026-10-18