One way to ship: check, merge, deploy, live, rollback
Ticket #356. Status: the standard, ruled 2026-11-11 (§6). It started as a spike; the
owner ruled on every question, and the rollout tickets link #356.
Spike inputs: the CLAUDE.md deploy section and the Forgejo workflows of each active repo (read on
2026-11-11 through the API, default branch), the infra repo's deploy: <app>@<sha> commits,
fleet's continuous deploy (fleet-autodeploy in the operator repo), the worker brief that
sends ready <branch> <sha> to a merge train, and the Work board Live rule (#355).
Names: the infra repo is the repo of cluster manifests (<infra-repo> in examples). Production cluster and
development cluster are the two k3s clusters. A train is the fleet agent that merges
ticket branches for one repo (swarm-lab used merge-train2 until it went trunk-based, #576).
1. The standard
Every repo ships the same eight steps. A repo says how it does each one in .fleet/ship.yaml
(§2). Tools (merge trains, the Work board, continuous deploy, the rollback command) read that
file and nothing else.
-
One worker per ticket, on
t/<n>. The worker never pushes the default branch. It pushes unfinished work towip/<n>, where no check runs, and pushest/<n>only when the work is ready; then it sendsready t/<n> <sha>(Q14). -
One check workflow, on ticket branches, train stacks, the default branch and tags. It triggers on
t/**,train/**, the default branch and tags, never onwip/**or any other branch, so it runs once per ticket, at ready (Q14). The check runs on the exact sha that will be merged. Main only moves by fast-forward (Q1), so a push to the default branch carries a sha whose check already passed ont/**ortrain/**. The run there starts with aseenjob that finds that passed run and skips the gate (pattern: swarm-lab.forgejo/scripts/seen.sh, #353). Any doubt (API error, no match) runs the gate. Without it the suite runs twice per change (sidegig fe492f8, 2026-11-11: the default-branch run was still testing when the deploy ended). "Green" means: the check workflow's run for that sha has.status == success. The check is the full gate (lint, format, types, tests, contract checks). For a repo with an artifact (an image, a release binary), the check also builds it for that exact sha and pushes it tagged by the sha (<registry>/<app>:<short-sha>), so the sha that goes on the default branch already has its artifact. The deploy neither runs the gate again nor builds (step 4, Q12). A newer push to the same branch cancels the older run on that branch (concurrency: group per ref,cancel-in-progress: true); runs on the default branch and on tags are never cancelled (their group is the sha) (Q13). -
The train merges by fast-forward only. It takes
ready t/<n> <sha>messages, stacks ready branches in order on top of the default branch (rebase), pushes the stack astrain/<k>, waits for the check on the stack's head sha, then fast-forwards the default branch to exactly that sha. A green branch that is already on top of the default branch is fast-forwarded at once, with no second check run; only a stack that was rebased (a new sha) is checked again, and that check builds the stack's artifact (Q12). A red stack is bisected: the first red ticket is sent back, the rest are re-stacked. A ready that comes while a stack's check runs does not wait for it: it is rebased on that stack's head and pushed as atrain/<k>of its own, so its full check runs at once; it goes on the default branch after the stack under it, at the sha that was checked. Result: the sha on the default branch is always a sha the check passed. No pull requests. A batch of one is the normal case when traffic is low. Trunk variant of steps 1-3 (merge.mode: trunk,docs/fleet/trunk.md): (1) the worker pusheswip/<n>and, when the work is ready, runsfleet land; not/<n>, noready. (2) The check workflow triggers oncheck/**, not ont/**ortrain/**: the trunk guard pushescheck/<sha12>at main's newest head, so one full run covers every commit landed since the last one. "Green" is the same rule. (3)fleet landrebases on the default branch, runscheck.local(with the default branch's copy of the files.fleet/local-gate-fileslists there, if it lists any, so a landing cannot weaken its own gate), and fast-forwards (never force). The guard bisects a red head, reverts the culprit as a forward commit and sends its ticket back; a red head may sit on the default branch for a few minutes. Only a green sha is released. The train stays in the binary as the rollback: setmerge.mode: train. -
A push to the default branch runs the deploy workflow. It confirms that the check passed for this sha (one API read), pins the artifact that the check built for this sha (
ship-deploy.sh), rolls it out and waits until/versionshows the sha. It runs no tests and builds nothing (Q2, Q12). Target: merge to Live in under 2 minutes for a cluster app. Deploys run one at a time per repo (concurrency), newest wins. -
Live is observed, not claimed. Fleet marks a ticket Live when the target reports a deployed sha that contains the ticket's merge. Each kind has one observer (§2
live). The strongest observer is the running service saying which sha it runs (/version); the weaker ones (a green deploy run, adeploy:commit) are allowed while a repo has no such endpoint. Observing, rather than a push from CI, also catches manual deploys and rollbacks: if production goes back to an older sha, cards leave Live. The record of a deploy has one format,deploy: <app>@<short-sha>: in the infra repo for cluster apps, in the app's own repo for an app that deploys itself (ship.yaml names the repo). -
One rollback command.
fleet ship rollback <repo> [<sha>]readsrollbackfrom ship.yaml, deploys the previous good artifact (or the named one) through the same path as a deploy, and waits for the same health check. It writes a newdeploy:commit that pins the older artifact: history moves forward and is never rewritten. No rebuild: the old artifact is still in the registry. The rollback is reported like a deploy, so the board shows it.Rollback (
fleet ship rollback, #383). It reads.fleet/ship.yamlfrom the repo's default branch on Forgejo (FORGEJO_URL,FORGEJO_OWNERfor a bare<repo>, andFORGEJO_TOKEN; the URL and owner default to theoriginremote of the working directory).- Target. With no
<sha>: the newestdeploy: <app>@<short>record (in the repo oflive's deploy-commit observer or--records; a cluster app must name its infra repo there, any other kind defaults to the repo itself) is the current deploy; the target is the newest record before it whose commit is older than the current one, so a second rollback goes further back instead of returning to the sha it left. With<sha>: that sha, older or newer (a roll forward). - Check. It refuses a target whose
check.workflowrun (thecheck.jobs, else every job) for that exact sha did not pass, the rule ofship-check-passed.sh. - How.
redeploy-previous: it dispatchesdeploy.workflowon the default branch byworkflow_dispatchwith the inputsha(the full sha); the workflow skips its build wheninputs.shais set and callsship-deploy.sh --sha <inputs.sha>, which writes the newdeploy:record.--local --script <ship-deploy.sh> -- <flags>runs the script here instead, adding--app,--shaand the health and version URLs of ship.yaml.command: it runsrollback.commandwith{sha},{short_sha}and{tag}filled ({tag}:--tag, else a tag that points at the sha). - Wait. Like a deploy: until
health.urlanswershealth.expect(orhealth.commandexits 0) andliveshows the target (the version URL answers the sha, else the newest record is the sha), up tohealth.timeout. It exits non-zero when the target is not observed in that time. --dry-runprints the target, the check it read, what it would run and what it would wait for, and changes nothing.
- Target. With no
-
.fleet/ship.yamlin every repo. One file, checked byfleet ship lintin the check workflow (step 2), so a stale file fails the gate. -
This document plus a new-repo checklist (§5). A repo is "on the standard" when every row of the checklist is true.
What the standard does not fix: how a repo builds (Dockerfile, uv, Go), which cluster it runs on, or its local gates. It fixes the order, the signals, and where they are written down.
2. .fleet/ship.yaml
version: 1
kind: cluster-app # cluster-app | fleet-release | static-site | cli-tool
default_branch: main
branches: "t/*" # ticket branches the train accepts
check: # step 2
workflow: ci.yaml # file in .forgejo/workflows; must run on push to t/**, train/** and the default branch (Q14)
jobs: [lint, test] # job names of that workflow that must pass (optional; default: every job of it)
local: make check # what a worker runs before `ready` (optional)
merge: # step 3
mode: train # train | direct (direct only for a repo with no workers)
train: merge-train-<repo> # fleet agent name
batch_max: 5
deploy: # step 4
trigger: push # push (to default_branch) | tag | manual
workflow: deploy.yaml # for push and tag; for manual: command
command: "" # e.g. "make release" (manual only)
artifact: registry.example/<app>:{short_sha}
live: # step 5: how fleet observes what is deployed
by: version-url # version-url | workflow | deploy-commit | release | branch
url: https://app.example/version # version-url: GET returns the full or short sha
# workflow: a run of deploy.workflow succeeded on default_branch for the sha
# deploy-commit: repo + pattern, e.g. {repo: <infra-repo>, match: "deploy: <app>@{short_sha}"}
# release: the fleet server and nodes report a version whose tag contains the sha
# branch: merged to default_branch is live (a tool installed from the branch head)
health: # deploy and rollback both wait for this
url: https://app.example/healthz
expect: 200
timeout: 600s
rollback: # step 6
how: redeploy-previous # redeploy-previous | revert-deploy-commit | command
command: "" # for how: command
notify:
on_fail: owner # who hears about a red check, deploy or health: owner | channel:<name>
on_live: board # board only (no message); a channel may subscribe
With merge.mode: trunk the file may add a trunk: block (all keys optional; merge.train is
not needed). fleet ship lint rejects trunk: without merge.mode: trunk:
merge:
mode: trunk
trunk:
check_ref: "check/" # prefix of the guard's refs; the check workflow runs on <check_ref>**
land_tries: 5 # fleet land's push tries when main moves
red_alert: 30m # tell notify.on_fail when main stays red this long
bisect_parallel: 4 # probes at once on a red head; 1 is serial (#691)
protect: # paths fleet land refuses without --protected
- fleet/api/openapi.yaml
Rules for the file: unknown keys fail fleet ship lint; live.by: version-url needs url;
deploy.trigger: manual needs command; merge.mode: direct is refused when the repo has a
train. Defaults: branches: "t/*", batch_max: 5, health.expect: 200, timeout: 600s.
The train's check (#381): a sha is green when every job named in check.jobs of
check.workflow has .status == success on that sha; without check.jobs, every job of that
workflow (a job its own if: skipped does not count). The train reads ship.yaml on the default
branch, so a branch cannot loosen its own gate, and merges to default_branch (else the
Forgejo default branch). A repo with no ship.yaml: swarm-lab keeps lint, test and build
of fleet.yml (its ship.yaml also lists test-2 and test-3, the other shards of the suite, #354); any other repo needs every job of every workflow that ran on the sha. The merge
comment names the rule it used.
A rerun of the check (#454): Forgejo posts the job statuses (<workflow> / <job> (push)) only for
a run started by a push. A run started by workflow_dispatch (a worker's rerun of the same sha
after a flaky test) leaves no job status, so the train never sees it green. A check workflow
that allows workflow_dispatch posts each gate job's status itself on a dispatch run, with the
push context: pending after checkout and the job's result in a last if: always() step
(swarm-lab: .forgejo/scripts/gate-status.sh). The combined status keeps the newest status of
each context, so the rerun replaces the push run's result. A workflow without those steps must
not allow workflow_dispatch; there, the rerun is an empty commit pushed to t/<n>.
Example: cluster app (an app image, manifests in the infra repo)
version: 1
kind: cluster-app
default_branch: main
check: {workflow: ci.yaml, local: make check}
merge: {mode: train, train: merge-train-dpcdirectory}
deploy: {trigger: push, workflow: deploy.yaml, artifact: "registry.example/dpc:{short_sha}"}
live:
by: version-url
url: https://directprimarycare.directory/version
fallback: {by: deploy-commit, repo: <infra-repo>, match: "deploy: dpc@{short_sha}"}
health: {url: https://directprimarycare.directory/healthz, timeout: 600s}
rollback: {how: redeploy-previous}
notify: {on_fail: owner}
redeploy-previous for a cluster app: run the deploy workflow's apply step with the previous
deploy: <app>@<sha> tag, which writes a new deploy: commit (history moves forward, it is
not rewritten) and waits for rollout status plus the health URL.
Example: fleet release
version: 1
kind: fleet-release
default_branch: main
check: {workflow: fleet.yml, local: "make -C fleet pre-land"}
merge: {mode: trunk}
trunk: {protect: [fleet/api/openapi.yaml, docs/fleet/ledger-v1.json]}
deploy: {trigger: tag, workflow: fleet-release.yml, artifact: "fleet {tag}"}
live: {by: release}
health: {command: fleet version}
rollback: {how: command, command: "fleet-deploy <previous tag>"}
notify: {on_fail: owner}
swarm-lab is trunk-based since #576 (docs/fleet/trunk.md); its real ship.yaml lists every
contract in trunk.protect. The continuous deploy (fleet-autodeploy) is the tagger: the newest
green sha on main (checked on the trunk guard's check/<sha12> ref, any passed run counts) →
next rc tag → deploy server and nodes.
Example: static site
version: 1
kind: static-site
default_branch: main
check: {workflow: ci.yaml, local: make check}
merge: {mode: train, train: merge-train-<repo>}
deploy: {trigger: push, workflow: deploy.yaml, artifact: "bucket://<site>/{short_sha}/"}
live: {by: version-url, url: https://<site>/version.txt}
health: {url: https://<site>/, expect: 200, timeout: 120s}
rollback: {how: redeploy-previous} # point the site at the previous {short_sha}/ prefix
notify: {on_fail: owner}
Build once into a sha-named prefix, then switch the served prefix; the previous prefix stays,
so rollback is a pointer change. version.txt is written by the build. No repo is a static
site today; this is the shape the next one should take.
Example: CLI tool
version: 1
kind: cli-tool
default_branch: main
check: {workflow: ci.yaml, local: make check}
merge: {mode: train, train: merge-train-imagery}
deploy: {trigger: push, workflow: "", command: ""} # users install from the branch head
live: {by: branch}
health: {command: imagery --version}
rollback: {how: command, command: "uv tool install --force git+ssh://git@git.example/owner/imagery.git@{sha}"}
notify: {on_fail: owner}
A CLI that is installed from the branch head is live when it is merged. If later the tool is
installed per box and the boxes must be current, the node reports <tool> --version and
live.by becomes release-like; not needed now.
3. Audit (default branches, 2026-11-11)
"Branch check" = a check workflow runs on a push to t/*. "Build once" = the deploy builds
an artifact tagged by sha and does not re-run tests that already ran on that sha.
| Repo | Branch | Branch check | Merge path | Deploy | Build once | Health after rollout | Live signal today | Rollback today |
|---|---|---|---|---|---|---|---|---|
| dpcdirectory | main | partly: branch-ci.yaml runs on w*/**, w*-*, staging, not t/*; test.yaml on PRs only |
train (chief / train) | push to main: build-deploy.yaml (re-runs the test job as its gate), image dpc:<short>, deploy: dpc@<sha> in infra repo, apply, rollout status for 2 deployments, cache purge |
no (suite runs again) | rollout status only |
none on the board (#355) | revert the deploy: commit and apply (not written in the repo) |
| publicdata | main | partly: web.yaml on PRs for web/**; backend.yaml only on main |
direct | manual make release TAG=<short> from a clean main; pins kustomization, applies, deploy: publicdata@<tag> in its own repo; development cluster |
yes | rollout status + documented public-path check |
none | documented: pick the previous tag from git log --grep='^deploy: publicdata@' |
| sidegig | master | no (ci.yaml on master only) |
scripts/merge-train.sh (local gates, one push) |
push to master: ci.yaml ruff + test + formal, then build, deploy: sidegig@<sha>, apply, rollout status |
no (suite runs after merge, not before) | rollout status only |
none | revert deploy: commit (not written) |
| dtm-lol | master | no | direct | push to master: ci.yaml build + deploy, no test job; deploy: dtm-lol@<sha> pushed with a plain git push (no rebase retry, the race fixed elsewhere by infra #136); header comment says "no registry" but it pushes to the registry |
yes | rollout status only |
none | revert deploy: commit (not written) |
| infra repo | master | no; validate.yaml (validate + server dry-run) on master |
direct, plus deploy: commits from app CI |
itself: kubectl apply by hand; tofu.yaml plans on push, applies on dispatch; owns a reusable build-and-deploy.yaml that no app uses (cross-repo runs-on not resolved, so apps inline copies) |
n/a | n/a | n/a | git revert + apply |
| imagery | main | no CI, no CLAUDE.md | direct | none: uv tool install git+ssh://<git host>/… on each box |
n/a | n/a | none | install an older ref |
| swarm-lab | main | yes: fleet.yml on the trunk guard's check/** refs |
trunk (fleet land, trunk guard on check/**, #576) |
continuous deploy: green main → rc tag → fleet-deploy server + nodes; fleet-release.yml on tag |
yes | fleet version on each target |
yes: board Live when the deployed release contains the commit | deploy the previous tag (fleet-release skill) |
| media-mcp | master | no (ci.yaml on master) |
direct | push to master: build test stage then image, deploy: media-mcp@<sha>, apply, rollout status |
yes (test is a build stage of the same build) | rollout status only |
none | revert deploy: commit (not written) |
| heb-api | master | no CI | direct | manual make release from a laptop (clean tree; rsync to the development box, build, push, pin kustomization, roll); commit Deploy <sha>: … in its own repo |
yes | manual | none | re-pin an older tag (runbook) |
Patterns seen:
- Three deploy-commit formats.
deploy: <app>@<sha>in the infra repo (dpcdirectory, sidegig, dtm-lol, media-mcp),deploy: publicdata@<tag>in the app's own repo, andDeploy <sha>: <what>in heb-api. One format, one place, makesdeploy-commita single rule. - Four copies of one deploy job. dpcdirectory, sidegig, dtm-lol and media-mcp each inline
the infra repo's build-and-deploy steps; dtm-lol's copy lacks the push retry. A shared
script in the infra repo (called by path after checkout, which avoids the cross-repo
uses:problem) removes the drift. - Only swarm-lab checks branches. Elsewhere the first check of a sha is after it is on the default branch, so a red merge reaches the deploy job (sidegig, dpcdirectory block it there; dtm-lol does not test at all).
- No app exposes the sha it runs. Health is
rollout status(pods ready), which does not prove the right image answers on the public path.
4. Changes per repo
Order: first the shared pieces (A), then repos by traffic (dpcdirectory first, it is the one the board misses today).
"On every branch" in this table was written before Q14: read it as t/**, train/**, the
default branch and tags, never wip/**.
A. Shared (swarm-lab and infra repo)
- swarm-lab:
fleet ship lintand the ship.yaml loader; the Work board readslivefrom it (this generalises #355's per-project rule: #355's (a) isrelease, (b) isworkflow, (c) isdeploy-commit, plusversion-urlandbranch). Until ship.yaml lands, #355's project setting is the stopgap and its values map one to one. - swarm-lab:
fleet ship rollback <repo> [<sha>]. - swarm-lab: one train per repo (
merge-train-<repo>), with the fast-forward-after-check stack of §1 step 3. The train readsmergefrom ship.yaml. #378 moves the plain merge (one green branch, fast-forward) intofleet serve; the per-repo config is what both the train agent and the server read. - Infra repo:
scripts/ship-deploy.sh <app> <short-sha>(sed the image, verify, commitdeploy: <app>@<sha>with pull-rebase retry, apply,rollout status, health URL), called from each app's deploy workflow. Retire the unused reusable workflow or make it the wrapper.
B. Per repo
| Repo | Changes |
|---|---|
| dpcdirectory | ci.yaml on every branch (replace branch-ci.yaml's w* patterns with all branches; fold ruff/typecheck/test into it); deploy confirms the check for the sha instead of re-running the suite; call ship-deploy.sh; add /version; ship.yaml; train merge-train-dpcdirectory. |
| publicdata | ci.yaml on every branch (backend + web gates); then deploy.yaml on push to main (the make release steps in CI), deploy: publicdata@<short-sha> in its own repo, /version; ship.yaml deploy.trigger: push. Until the branch check runs, the deploy stays by hand (trigger: manual). When the automatic deploy is live, remove "ask before any public deploy" from its CLAUDE.md (Q5). |
| sidegig | split ci.yaml into ci.yaml (all branches: ruff, test, formal) and deploy.yaml (master: confirm check, build, ship-deploy.sh); retire scripts/merge-train.sh for the fleet train; /version; ship.yaml. |
| dtm-lol | add a check workflow (it has none); split deploy; use ship-deploy.sh (fixes the push race); fix the stale "no registry" comment; /version; ship.yaml. |
| infra repo | ship-deploy.sh (A4); validate.yaml on every branch push; its own ship.yaml with deploy.trigger: manual: it is applied by hand, not on push (Q7). |
| imagery | CLAUDE.md (missing); ci.yaml (ruff, format, mypy, pytest) on every branch; ship.yaml kind: cli-tool, live.by: branch. |
| swarm-lab | ship.yaml (kind: fleet-release); delete the dead .github/workflows copies; nothing else (it is the reference). |
| media-mcp | split check (all branches: the test build stage) from deploy; ship-deploy.sh; /version; ship.yaml. |
| heb-api | ci.yaml on every branch; deploy.yaml on push to master, on a CI runner on the development box (where its image is built today), no laptop step (Q6); deploy: heb-api@<short-sha> in its own repo; /version; ship.yaml. |
5. New-repo checklist
A repo is on the standard when each line is true.
-
CLAUDE.mdhas a "Ship" section that points to.fleet/ship.yamland this document. -
.forgejo/workflows/ci.yamlruns the full gate on a push tot/**,train/**, the default branch and tags (notwip/**, Q14), and runsfleet ship lint. If it also allowsworkflow_dispatch, each gate job posts its own<workflow> / <job> (push)status on a dispatch run (#454, §2 "A rerun of the check"). A newer push to a branch cancels the older run of that branch; never on the default branch or a tag (Q13):concurrency: group: ci-${{ (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')) && github.sha || github.ref }} cancel-in-progress: true(Use the repo's own default branch name in place of
main.) -
.fleet/ship.yamlexists and lints. -
The check builds the artifact for its sha and pushes it tagged by the sha. The deploy (if any) is triggered by the default branch or a tag, confirms the check passed for that sha, pins that artifact, and neither re-runs the gate nor builds.
-
The running service answers
/versionwith its sha, and/healthz. -
fleet ship rollback <repo>has been run once against a test deploy and worked. -
The repo has a train agent, or
merge.mode: directwith a reason.
The default branch is not locked (Q11). The train is the only path that the standard uses; a person can still push in an emergency.
6. Rulings (2026-11-11)
The owner ruled on product questions, the chief on technical ones (Q9, Q10). A change is a new ruling, written here.
| # | Question | Ruling |
|---|---|---|
| Q1 | Fast-forward only, or merge commits? | Fast-forward only: the default branch moves only to a sha whose own check passed. (owner) |
| Q2 | Does the deploy re-run the tests? | No. It confirms that the check passed for the exact sha (one API read) and refuses otherwise. (owner) |
| Q3 | Live by observation or by a push from the deploy? | Observed. Every service answers /version with its sha; the deploy: commit is the fallback. (owner) |
| Q4 | One deploy-commit format? | deploy: <app>@<short-sha>. In the infra repo for cluster apps; publicdata and heb-api write it in their own repo, and ship.yaml names the repo. (owner) |
| Q5 | May publicdata deploy from CI on merge? | Yes, automatically on merge once its check runs on every branch; by hand until then. When the automatic deploy is live, remove the "ask before any public deploy" rule from its CLAUDE.md. (owner) |
| Q6 | heb-api deploys from a laptop. Move it to CI? | Yes: from CI, on a runner on the development box where its image is built today. No laptop step. (owner) |
| Q7 | Is the infra repo applied on push? | No. It is applied by hand; validate.yaml runs on every branch push. (owner) |
| Q8 | One train per repo, or one for all? | One train per repo. (owner) |
| Q9 | Where does ship.yaml live? | .fleet/ship.yaml in each repo. The #355 project setting is a fallback only. (chief) |
| Q10 | Rollback: a revert or a new commit? | A new deploy: commit that pins the older artifact. History moves forward; cards leave Live when the older sha is observed. (chief) |
| Q11 | Lock the default branch? | No lock. No branch protection change; checklist item "protected default branch" is dropped. (owner) |
| Q12 | How fast must a deploy be? (2026-11-11 08:00, after "we really need to speed up deploys") | Merge to Live in under 2 minutes for every cluster app. The full suite runs once per sha: the branch check also builds and pushes the artifact for that sha; the train fast-forwards a green branch that is already on top of the default branch with no second run and re-checks only a rebased stack; the deploy runs no tests and builds nothing, it pins the artifact, applies and waits for /version. Measured before: fleet 2-3 min merge to live; dpcdirectory 13.5 min from merge to its deploy commit, suite run three times per change. dpcdirectory first, proven with before/after timestamps on 3 real changes. (chief) |
| Q13 | Does every push run its check to the end? (2026-11-11 08:58) | No. A newer push to the same branch cancels the older run on that branch: concurrency with the ref as the group and cancel-in-progress: true. Never on the default branch or tags: there the group is the sha. Measured before: 08:28-08:58 the 3 CI runners ran 323 jobs for about 9 merged tickets, about 35 jobs per ticket, because workers push several times per ticket and every push ran 4-5 jobs to the end. fleet.yml first, then every repo's check workflow. (chief) |
| Q14 | Why does CI run on every push? (2026-11-11 09:08, the owner's question) | It runs once per ticket, when the worker is ready. Check workflows trigger on t/**, train/**, the default branch and tags only, never on wip/**. Workers push unfinished work to wip/<n> (no CI) and push t/<n> only at ready, then send ready. A newer push to the same branch still cancels the older run (Q13); merge and deploy reuse the green check (Q2, Q12). Measured: jobs per merged ticket before and after (baseline 08:28-08:58: 323 jobs for about 9 tickets). (chief) |