Dev Pipeline Maintenance
Need space now, or working through a worktree backlog? Use the manual cleanup and space-recovery process; the daily scheduled cleanup described here is separate. The Dev Pipeline's daily maintenance run reaps finished worktrees and reports what is waiting to land, and this page covers what the unattended run does, what the verifier checks and how to stop it. The old worktree-cleanup and merge-all-ready skills are retired.
On this page
What it is
Dev Pipeline Maintenance is the daily run that keeps your repos tidy without you lifting a finger. It used to ship two housekeeping skills, worktree-cleanup and merge-all-ready; both were retired on 2026-11-05. Their jobs now belong to:
- The worktree reaper — removes the git worktrees left behind by finished work, saving any unsaved work first (worktree-reaper.md).
- The auto-lander (the Land ready branches automatically switch in the Dev Pipeline panel, labelled Auto-lander (land ready branches automatically) in Settings → PR Merge Queue) — lands every branch tagged ready-to-merge onto your local integration branch.
What the retired skills did
- worktree-cleanup — reaps the git worktrees left behind by finished work. It removes a worktree only when its branch's work is provably landed in the integration branch (
main, elsemaster), judged by content (patch-id) so it also catches rebase / replay landings, not just direct ancestors — with GitHub PR status as an extra signal when available, never required. A squash- or fast-forward-landed branch is judged too (fixed 2026-10-11): those lands leave no landing merge to measure, so the content check falls back to the branch tip's own boundary and runs the same per-path proof. It still refuses a branch whose landing was reverted, which is the whole reason the content check exists. It never removes a locked, dirty, active, or unmerged worktree, and never the main checkout, and every delete is reversible (it records a recovery SHA before deleting a branch, and saves a patch of any uncommitted work first). On request it can also archive idle unmerged worktrees (reclaim disk, keep the branch) and clean up stale local branch refs. - merge-all-ready — lands every local branch marked ready-to-merge onto the integration branch, one at a time, atomically and local-only (it never pushes and never touches
origin). A clean or fast-forward merge lands automatically; a conflict is resolved only when it can be done safely and verifiably, otherwise the branch is skipped and reported. It never force-merges and never loses committed work.
If you still have them installed
Neither skill is installed any more: the app removes the copies it installed itself; a copy you edited by hand is left for you to delete.
Where to find it
There is nothing to open for the daily run — it happens on its own, on the schedule described below. The off switch is under How it behaves.
How it behaves
The daily automatic run
As part of the Dev Pipeline, Omniscio runs a maintenance pass automatically once a day. Each day the in-process maintenance job:
- runs a free, deterministic check of the whole landing-and-cleanup system first (see What the daily verifier checks) — it reads what the app already knows and costs nothing,
- finds the hubs that had development work that day (a dev-pipeline run), that participate in the pipeline (per the Dev Pipeline panel's "Which repos"), and that actually hold a git repository — a hub is where a session was created, not necessarily the repo its work sat in, so a notes hub, a data folder or an agent home is never a maintenance target and never receives one of these sessions,
- and, only when the check comes back needing a person about something new (or there is a leftover branch or folder to pick up), spawns one background session for that repo to remove finished worktrees through the app's own safe door, then report on the landing queue. A day the check is clean buys no session at all — a healthy fleet costs nothing — and a pile the report already named on an earlier night buys nothing either, so the run logs a skip reason instead.
The daily run does not land anything — it never has since 2026-09-09. It reads the auto-lander's queue and status and tells you what is waiting and what is stuck. The auto-lander is the one thing that moves your integration branch. This changed after a daily run swept alongside the armed lander and landed a branch its author had deliberately marked on hold: two movers on one branch is a defect, not a safety net.
It is on by default whenever the Dev Pipeline is enabled, with an off switch in the Dev Pipeline panel → Setup → All settings (devPipelineDailyMaintenanceEnabled). Cost is bounded: at most one session per repo per day and only when the free check finds something that needs a person, the run honors your daily spend cap, and a per-day repo limit caps a busy day. If a run fails to start (the spend cap refused it, or the computer could not prepare its working folder), that repo waits longer before each new try — two hours, then four, then eight, up to a day — instead of opening a new session every hour, and the wait resets the first time a run starts. If Omniscio cannot save its note that a repo was already handled today, it starts nothing rather than risk paying twice. A finding that is about the whole computer rather than one repo — a check the verifier makes once, like the main checkout or the cleanup schedule — is named in exactly one of that night's reports and buys exactly one session, instead of being repeated into every repo's report and paying for one run per repo. By default it runs on a lighter, lower-cost model (DeepSeek V4.1 Flash) to keep it cheap, and the picker below the toggle sets the engine, model and thinking level it uses. The daily job does not re-trigger off its own runs today: a maintenance session drives the app's own cleanup route rather than the pipeline, so it records no dev-pipeline run — and a dev-pipeline run is the only thing the "had development work today" signal looks at. That rests on the session's instructions, not a check — the activity query filters nothing about where a run came from — so a session that drove the pipeline itself would feed the job. The tag is provenance, not a guard.
Every stranded branch and working folder is accounted for. After the cleanup, the run
accounts for everything it could not clear: working folders a safety rule kept (with the rule that
kept each one), dev-pipeline runs that stopped part-way, and branches the auto-lander set aside after
its rescue attempts ran out. Each one is named once, the first night it appears; on later nights
the same pile is reported only as a count (still waiting: N) instead of being listed again, so a run
that finds nothing new is a few lines rather than hundreds. A name returns to the list after a week,
so nothing can sit unwatched for good — and each night works the next slice of the pile, not the
same slice. The window rotates, so a long-standing pile of a thousand items is genuinely worked
through night by night instead of the first few being re-named for ever while the rest are never
looked at; and the bigger the pile, the more the run names in one night, so it finishes the sweep in
about a month rather than never. Anything you could pick up gets a one-click link that opens a
new session for it as an unsent draft — the brief is filled in, and nothing starts or costs anything
until you read it and press send. The run never starts those sessions itself. Before it names an
item it re-checks it, at the moment of use. A run lasts hours, and the app's list was taken before
the run started, so in that time the lifecycle can already have closed the item — the folder retired,
the branch landed. An item like that is skipped: never named, and given no pickup link, so the report
never spends a line on work that is already done. If it could not read
one of those lists, it says so rather than reporting "none". The list of branches your own auto-lander
rule kept is read from the same ledger, and if that read fails the report says so in plain words
where the list would be — it never shows you an empty list and lets you read it as "nothing to
decide".
A restarted run re-reads the facts before it starts. The app gathers what the run needs (the kept-branch list, the stranded items, the rescue candidates) and hands it over in the prompt, so the session does not spend its first minutes looking things up. That handover is a snapshot, and a run can be restarted hours later — the cheap model refuses the turn, the app moves the session to another engine, or the session is brought back after a restart. Re-sending the snapshot verbatim would ask you about work that has since been finished. So the prompt carries the moment its facts were read, and any delivery more than a couple of minutes after that moment rebuilds the selection first: the kept-branch list, the stranded count and the rescue candidates are read again, and a branch the hourly retire has since proved finished is simply not in the list you are shown. A first launch is untouched — it is sent exactly as it was built.
Work nobody owns, it just finishes. A working folder or branch whose owner session has gone and whose work never landed is not handed back to you as a question — the run finishes and lands it through the ordinary road itself, and files an improvement so automation catches that kind next time. It never touches work a session that is still open holds, and it never starts a second session to do it. Nor does it touch a branch that has been parked for your own decision — one waiting on your complete-or-drop list — because that one is still yours to rule on, and the same goes for a branch you have already answered there: keeping or dropping it leaves the branch itself in place, so it stays yours either way. If it cannot check that list, it finishes and lands nothing at all that night rather than guess wrong about whose work it is.
No alert spam — the session just talks to you. The cleanup session itself raises no inbox alerts or cards; its report is the one place it tells you anything. The free verifier that runs ahead of it is the exception: when a check needs a look it raises one lifecycle card for the day, and when a day's check never ran it raises a missing day card — both described below.
It only writes to you when there is a question for you. A run that went fine — whether it found nothing to do or reaped four worktrees and investigated three branches — quietly archives itself, so your inbox stays clean. Exactly two things bring it to your inbox: it carries the one lettered question only you can answer, or the job itself could not run. That question is:
- an old-branch delete card left waiting — A. approve the delete · B. keep them.
Branches are never a question. The run used to ask you to pick a label for a leftover branch — keep it, investigate it, or retire it, and separately whether to rescue or park work at risk. It does not any more, because "investigate" was always its own job: it holds the branch, the diff and the merge tooling, so it is better placed to settle a branch than you are to choose between two words. A branch holding work nobody landed is now investigated and acted on — the run proves whether the work is already on master by comparing content (not history, because a cherry-pick makes history lie), finishes it through the normal ready-to-merge road if it is not, and otherwise tells you exactly what stopped it. You are told what it did, never asked to decide.
Everything else — a working folder you could pick up, a branch it could not land safely, a conflict it
could not resolve, a cleanup step that kept failing, the cleaner removing nothing, or the reason a
folder refused to be cleaned — is named once in
the report, has an improvement filed for it, and does not sit in your inbox waiting to be dismissed.
A large number is never on its own one of these: a big backlog is stated in the summary's Backlog
line every run, but a number is not a question. Then it reports back in a short, scannable summary,
ending with one line saying how much the run had to handle by hand itself and how many improvements it
filed for it — caught by hand: N, improvements filed: M. Nothing is lost when it archives — every run
stays readable in your Archive, so you can always go see what it did.
A report that reaches you links to its own full detail — kept for a week. The message in your inbox is the short version: the question, what got done, and one Full details line. That link opens the whole report — every branch list, pickup link and number — as a page of its own, and it is kept for seven days, matching the week this run re-asks about the same branches. So a link older than that reads as expired by design rather than as a bug, and the next night's run publishes a fresh one alongside whatever it asks you again.
Old branches: cleared automatically, or left alone
Worktrees are only half the mess. A branch outlives its working folder, and local branches pile up far faster than the folders do.
If a branch is provably finished, it is deleted for you. No card, no question.
This sweep runs on its own — not only while the Dev Pipeline is on. It is a background job of its own: roughly once an hour it looks at every local branch in your repositories — not only the ones a worktree left behind, but branches you or an agent created by hand too — and deletes the ones whose work is provably already on your main branch. It needs no session, no worktree and no report, and it runs whether or not the Dev Pipeline is enabled.
On an installed copy it does not run until you turn it on. The sweep answers to the
orphanBranchSweepEnabled setting, and that setting ships off, so a downloaded Omniscio deletes
no branch this way until someone turns it on. There is no on-screen switch for it — set it from the
command line, the same way as the other command-line-only switches on this page. A run from source
has it on by default. Two more
things stop it wherever it is running: the operator's pause switch for the job, and the environment
variable AMC_DISABLE_ORPHAN_BRANCH_SWEEP=1 — so that environment variable is not the only off
switch. Every branch it deletes is recoverable: the
branch name and its tip are appended to ~/.amc/branch-reap/reaped-<day>.tsv (one file per day)
before the branch is removed, so git branch <name> <sha> brings it back.
Omniscio's own scratch never stays in a repository it does not own. While it lands work it uses
a temporary checkout of its own, and in a repository that is not Omniscio's that checkout is never
kept: it is not created up front, and one a particular landing needed is removed — with its
temporary branch — as soon as that landing succeeds. So git branch in your project lists your
branches, not Omniscio's bookkeeping. (In Omniscio's own repository the checkout is kept on purpose:
it is reused for every landing, and rebuilding it takes minutes.) Any checkout it cannot prove is
finished — one still holding work, or one it cannot read the answer about — is kept, not guessed at.
If it cannot be proven finished, it is left alone — nobody asks you. When work lands by being copied onto the main branch (a cherry-pick or a rebase) the copy gets a new identity, so neither of git's two "did this already land?" checks can see it. Both checks miss every such branch. There is no automatic proof to wait for, so only a person could decide. Omniscio used to ask once a day with approval cards. Since 2026-10-02 those cards are retired: almost every card was declined, and nobody wanted the daily question. Nothing is deleted. The daily report covers these branches instead: it counts them, an AI judges a batch of the oldest ones as finished, still holding work, or unsure, and it names the ones that still hold work. It works through the pile a batch at a time (fixed 2026-10-12): each day the review carries on where the last one stopped instead of re-reading the same oldest branches, so every branch is eventually judged — before this, the oldest handful were re-read for ever and the rest were never reached.
The "Check old branches daily" switch was removed on 2026-10-16. It only decided whether Omniscio also ran its own once-a-day check and noted the result in the app's log; the daily review above does that job, so there is nothing to switch on any more.
A card raised before 2026-10-02 is still reviewed for you. While one is waiting, the report lists every branch on it, oldest first and grouped by verdict, as likely replaced by later work (not proven) or still holds unique work, with its file count and age, and links straight to the card. A card you declined is your answer, and the report never brings it up again. The inbox's Approve all and Reject all (and the selection actions) skip these cards, so one sweep of the Approvals pile can never delete branches.
Every deletion leaves a recovery trail — but it is not all permanent. A branch tip is recorded
before the branch goes, and a branch that picked up new work since it was judged is skipped, not
deleted. How durable that record is depends on who deleted it: the approval-card path archives
to a ref nothing prunes, while the automatic sweep keeps a recorded tip in the branch-delete ledger
and a time-limited archive ref, and the bare-branch pass — which you run yourself — logs the branch
and its SHA before a git branch -D. So "deleted for you" means recoverable, never kept
forever.
A branch that something is still working in is kept too, and the reason is written down where you can find it. That covers a branch whose session is still running, one you pinned to keep, one carrying a hold, and — the case that used to slip through — one sitting in the middle of a rebase. A folder part-way through a rebase looks empty to the check that asks "is any working folder using this?", which is why a rebase in progress is now asked about separately rather than inferred.
The daily report also prints one number worth watching: branches per worktree. A branch should not outlive its working folder, so if that number is drifting up, the pile is growing.
"Background cleanup is slow on some old working folders." This card is about working folders, not about landing. When three or more of your working folders sit on branches that have fallen far behind the main branch (10,000 commits or more), Omniscio times one real background check on the furthest-behind of them, at most every six hours and never in the first ten minutes after the app starts. The card appears only if that check was slow — 15 seconds or more — and it says how long the check took and names the furthest-behind branches. It never asks you to delete anything: bringing a branch you still want up to date makes its checks fast again, and the card clears itself once the checks are fast.
What the daily verifier checks
Before it considers spending anything, the daily run does a free, automatic check that the whole landing-and-cleanup system actually worked. It reads what the app already knows — the worktree list, the landing records, your drives, and the background jobs — and answers eleven questions with real numbers:
- Did finished work reach master? Every branch marked ready in the last 24 hours either landed, or was handed back to you with a card in your inbox. A branch that did neither is the one thing this exists to catch: work that quietly went nowhere.
- Is anything stuck? Nothing sitting in the landing queue for more than 30 minutes with no result.
- Is there room on the disks? Every drive that holds worktrees is above its free-space floor, and no worktree is being created on the same drive as the code itself.
- Are old worktrees being cleaned up? Finished ones get their folder back promptly, and abandoned ones are cleared within a day. The count is stated out loud even when it's zero — a pile nobody counts is how this once grew to several hundred.
- Are the cleanup jobs running? The lander, the trash sweeper and the checkout keeper are all present and have each run recently.
- Is every landing traceable? Yesterday's landings each kept enough detail to answer "how long did that take" days later.
- Is the main copy of the code clean? On the main branch, up to date, and matching what was actually committed — including nothing missing from disk.
- Is anything sitting half-finished? A worktree that is still in progress — not finished, not abandoned, just stuck — is reported with the reason it is stuck and how long it has been that way. This is a separate question from "are old worktrees being cleaned up" on purpose, and the difference is the whole point: that one watches the queues that already have a cleaner behind them, and a draining queue was masking a pile of frozen work. Four different things can stick, and each needs a different fix — a setup that never finished, a worktree whose owning session is gone, one held far too long by a session that is still alive, and one marked ready to merge that never landed. Only that last one is treated as needing you; the rest are the machine being behind. Anything you have pinned is never reported, at any age.
- Can every parked spare slot be claimed? A worktree kept aside as a spare slot carries the identity a later claim re-checks it by; the question is red when a parked slot can no longer be claimed by anyone, because nothing will ever release it and its disk is held for nothing. The count is always given against the total, so "no spare slot is stuck" is never mistaken for "no spare slots are parked".
- Is the close-out review running? Once an hour a read-only pass looks at every open worktree record and writes down what the lifecycle would do with it — return the folder, keep the branch for the landing queue, hold it, or mark it stuck — beside what today's cleanup would do, without touching anything. It leaves a receipt before and after each pass. This question is red when a repo has no receipt inside two hours, when a pass started and never finished, when the last pass failed, or when the last pass still holds an open discrepancy — a bound it says was crossed and nothing has resolved — and the card names each repo it means, with the class holding most of that repo's open records. The ages the pass found — how many records are undecided, the oldest one, how many branches are past a week with nobody coming back — are carried along as detail; the open-discrepancy count is a verdict, because a repo stuck past a bound is exactly what the review exists to catch.
- Is the close-out cleanup running? The cleanup that acts on those decisions (returning folders and deleting finished branches) keeps receipts of its own, and this question asks the same of it: red when a repo has had no cleanup pass inside two hours, when a pass started and never finished, or when a pass did not finish cleanly (it hit an error, or had no decision to act on because the review was down). It is also red when three passes in a row held worktrees back and acted on none of them, or hit the limit on how much one pass may do, because a cleanup that runs but gets nowhere is not healthy either; the card names the repo and how many passes in a row. It is a separate question because a day where the review ran and the cleanup did not must not read as healthy. When all is well the line also says how many clean-up actions are on record. If the cleanup is switched off on this computer, the line says it is stood down instead of failing, because no pass is expected.
- Why is a worktree "held", and can I still remove it? The review holds a worktree only while a check could not finish, and tries again on the next pass. A worktree whose branch is very far behind master, or whose work landed as one combined commit, is no longer held: it is treated like any other branch whose work is not all on master — the folder may be put away and the branch is always kept. A worktree with no branch is checked by the commit it points at. While a worktree is held, the remove button refuses it; once the check answers, the remove you approved goes through.
A repo whose auto-landing you paused is skipped by both close-out questions. Close-out never runs on a paused repo, so no receipt is expected there: the passing line says how many repos were skipped, and a receipt left from before the pause no longer turns the card red.
A check it cannot run counts as a failure, never a pass. "We found no problems" and "we couldn't look" are different answers, and only one of them is good news.
What you see. Nothing, on a day everything worked — the result is filed quietly. When something is wrong you get one card, once a day, opening with Needs a look and a count. And if the check didn't run at all (usually because the app was closed) on the day before, you get a red card saying so the next time the daily check runs. It looks back at yesterday only — an older gap is not re-reported — and it raises nothing while the daily check is switched off, so a day missed while the feature is off passes quietly by design.
Asking any time. You don't have to wait for the daily run:
- Over the local API:
POST /lifecycle/verify/runon127.0.0.1:19519for a fresh pass;GET /lifecycle/verifyonly READS a stored receipt (and404s before that day's run).
Every run leaves a detailed record kept for 30 days, including the specific branch and folder names behind any problem — those stay out of the readable summary on purpose, and live in the record where they are useful for digging in later.
It also decides whether to spend anything. Because the check is free and thorough, the paid maintenance session now runs only when something genuinely needs a person's judgement — a real merge conflict, a stuck branch, a checkout somebody has to look at — and only when that something is new: a pile the report already named last night buys nothing, and the run logs why it skipped. A queue that is merely draining slowly is a machine being behind, not a decision, and no longer buys a session. If the check itself can't run, the session goes ahead anyway, so a blind spot can never quietly cancel your maintenance — an unreadable pile is unknown, not unchanged.
Working with the auto-lander
The auto-lander comes on with the Dev Pipeline — you do not enrol repositories by hand. That switch is a tri-state: left unset it follows the Dev Pipeline, and an explicit on or off wins from then on. When it follows the Dev Pipeline, it arms every real-git repository the Dev Pipeline covers automatically — each derived as enabled and not observe-only, because a repo the lander only watched would tell sessions to hand off to a lander that never moves the ref.
The per-repo list is an overlay on that set, not an allow-list. An entry can pause one repo, put it in observe-only (watch without ever moving the ref), or name the integration branch to land into — but it never removes a repo it omits. The one shape that speaks about the set is an explicit empty list, which is the disarm lever: it turns the lander off entirely. To drop a single repo, turn it off in the Dev Pipeline's own per-repo selection; to stop landing altogether, use the master toggle.
With the lander armed, it runs continuously and lands every branch that merges cleanly the moment it's tagged — the easy majority, on its own, with nothing else moving your branch alongside it.
Some branches it cannot finish unattended and hands back instead:
- branches it handed back because they hit a merge conflict (it never force-merges — it marks them for rework instead),
- branches it's stuck on (a tag whose commit has moved on, or a temporary repository snag),
- and anything still waiting when the auto-lander is off or the repo is not covered by the Dev Pipeline.
The daily maintenance run reports these; it does not sweep them.
The daily AI-code-review card
- You get one card per project per day, not a pile of review sessions. The AI Code Review phase starts its reviewers as sessions of their own, and those sessions are machinery: their findings go to the agent that asked for the review, and they are hidden from your session lists and inbox, whatever state they come to rest in — parked on a vendor's limit, ended, or failed. (A review that is still running stays visible, like any working session.)
- Instead, the daily run raises one card covering the day before — how many reviews ran, how many never answered, what they found, and what they cost, broken down by reviewer. The card names the project the reviews were run for and gives you one click into the Dev Pipeline panel, where the reviewer scorecard keeps the running per-model totals.
- The day is broken down by the kind of review that ran — plan checks, code reviews and mission reviews each get their own row, with their own review count, no-answers, attempts, findings and cost, so plan work is never folded into a code-review number. Those rows add up exactly to the card's own totals, a day that ran only one kind keeps the card exactly as it always looked, and a review whose kind nothing recorded is shown as "Kind not recorded" rather than guessed.
- It also counts the reviews the size floor could not measure. When a review's change cannot be sized at all, the review runs at the heaviest tier whatever was asked, and the card says so directly under the cost line: how many reviews that happened to, broken down by why the change could not be read (no base to measure from, the read timed out, git refused the read, the checkout is not on this machine), and how many of them the unreadability actually forced up to Heavy. A day with none says 0 rather than staying silent, and a day whose reviews cannot be matched to that project's reviewer attempts says that — "so how many failed to size is unknown" — instead of claiming a zero, because "none" and "we could not derive it" are different facts.
- These cards live in the Omniscio section, never in the reviewed project's. They are developer-internal machinery, so they are filed with the rest of the app's own notices rather than into a customer project's inbox — and the project each card is about is named in the card's own title, so nothing is lost by the move.
- A day with no reviews raises nothing, and a repeated run of the daily job refreshes the same card only if something about that day actually changed. A card you have not dismissed is left alone rather than re-announced, so it neither climbs the inbox nor counts up how often it fired.
- Turn it off like any other alert type: Settings → Alerts, under Ai review digest.
Safety
- Unattended by design, and unattended never lands. With no human watching, the daily run removes only provably-merged worktrees, and it only reports the landing queue.
- One worktree at a time, through the safe door. The nightly session clears already-finished worktrees one at a time through the app's own safe, reversible mechanism, never with raw git commands, so a busy stretch doesn't let the backlog pile up untouched until someone notices.
- It reads the whole backlog, not the top of it. The session asks the worktree list for its candidates in pages and keeps going until the list says there is nothing left, rather than trusting a single request to have returned everything. This matters more than it sounds: that request returns the most recently updated slice by default, so on a busy repo a one-request sweep sees only the newest handful of finished worktrees and reports a clean sweep while the older ones sit there — which is how a backlog quietly grows during runs that all looked successful. If a run ever reports finishing while the count of registered worktrees has not moved, that is the thing to look at.
- The number it reports is the reclaimable one, and a slow removal is waited on. The backlog a run states — before and after — is the figure the worktree list labels
reclaimableTotal: the finished worktrees whose folder is still on disk, less the ones the app is deliberately holding. It is never the list's overall row count, which also carries every worktree already proven gone and closed, so on an old install it can read in the thousands while a sweep has a couple of dozen real candidates. And when removing one candidate takes longer than the app will wait on a single request, the removal is not lost or assumed: the answer says it is still running and names where to read its outcome, which the run then reads before counting it either way. - A branch report never comes back empty. The classifier a run uses to judge the local branches prints each branch's evidence as it is gathered and names any branch it ran out of time for, rather than holding the whole answer until the end — so a report that was cut short still says what it did see and which branches it did not, instead of returning nothing at all.
- Local only. Landing never pushes and never touches any remote; landing means advancing your local integration branch.
- Never loses work. Neither the cleanup nor the landing discards uncommitted changes or unmerged commits; when in doubt, they keep and report. The one place in the worktree system where unsaved changes are dropped on purpose is the owner giving up its own checkout — an agent's own
POST /worktrees/:id/removeon a worktree it is the recorded owner of, which discards that owner's uncommitted and git-ignored changes with no rescue copy (Git guardrails). - One mover at a time. The auto-lander is the only thing that lands unattended, and no scheduled or automatic job is allowed to land alongside it.
On an installed app, and on a Mac
- The run is told what this computer actually has. An installed app has no auto-lander, and only Windows has the on-demand cleaner. The prompt changes to match, so the run never calls a route that would answer "not found" or "unavailable on this Mac".
- No auto-lander: the landing step is one routine line. The run says there is no landing queue on this computer and moves on. It is never reported as a problem, and the run never lands anything in its place.
- No on-demand cleaner: the run reports the in-app cleaner instead. It reads the cleaner's status (whether the automatic cleaner is on, and when it last removed something) and reports that in one line. The manual sweep that follows still runs on every computer.
- The app hands the run its own lists. Pending delete-old-branches cards for this repo, and this repo's stale pipeline runs, are read by the app when the run starts and written into the run's facts. If the app could not read a list, the run says "could not read", never "none".
- The run uses its own session key where it can. On an installed Mac every call the run still makes accepts the run's own key, so the prompt tells it to use that key. No key gets any new rights.
Which engine the daily run uses
- The run picks its engine from one setting, and you normally set it in the panel. The Dev Pipeline panel's Setup → All settings screen carries an Engine chip for the daily maintenance run; leaving it alone runs the built-in default (DeepSeek V4.1 Flash, the registry's
workertier on that engine), and picking a model sets that engine and model for every repo the run serves. - With Google connected, the default switches to Claude on its own. DeepSeek is turned off while your Google account is connected, so your Gmail, Calendar and Drive data never reaches it. When you have left the engine on its default, the daily run starts on Claude Sonnet 5.5 instead, rather than not starting at all. An engine you picked yourself is never changed.
- An agent can set it too, which is the point of
POST /dev-pipeline/maintenance/engine. The route takes an engine and a model together, plus an optional thinking level, and it applies at once — no approval card, no click. Sending both asnullputs the run back on its built-in default and clears the thinking level with it. - It only accepts what the Setup → All settings picker offers. The route and the picker read one engine list: native Claude, plus the alternate Claude Code vendors and ChatGPT (Codex) — those only while your Show alternate providers toggle is on. Codex can run the job because the run is calls to the app and needs no skill. The exception is the engine the run itself defaults to: that one is always accepted, so a reset can never hand back an engine the route would refuse. A provider still behind an unreleased feature is refused, as is a pair the spawn guard would never let start, and a thinking level sent for a vendor that exposes none.
- Nothing about this reaches a cloud box. The route is floored out of cloud sessions, so only the machine that pays for the nightly sessions can retarget them; every other setting stays as unreachable to an agent as it was.
- The answer is what is actually in force, read back after the write — so a caller that resets sees the real default rather than an echo of what it sent.
Turning it off
Turn it off in the panel under Setup → All settings, or switch the whole Dev Pipeline off.
Related
Dev Pipeline is the workflow these jobs ride with, and the Dev Pipeline panel is where its controls live.
Last verified 2026-11-15