Fleet docs v0.2.0-rc.448

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.

  1. One worker per ticket, on t/<n>. The worker never pushes the default branch. It pushes unfinished work to wip/<n>, where no check runs, and pushes t/<n> only when the work is ready; then it sends ready t/<n> <sha> (Q14).

  2. One check workflow, on ticket branches, train stacks, the default branch and tags. It triggers on t/**, train/**, the default branch and tags, never on wip/** 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 on t/** or train/**. The run there starts with a seen job 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).

  3. 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 as train/<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 a train/<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 pushes wip/<n> and, when the work is ready, runs fleet land; no t/<n>, no ready. (2) The check workflow triggers on check/**, not on t/** or train/**: the trunk guard pushes check/<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 land rebases on the default branch, runs check.local (with the default branch's copy of the files .fleet/local-gate-files lists 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: set merge.mode: train.

  4. 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 /version shows 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.

  5. 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, a deploy: 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).

  6. One rollback command. fleet ship rollback <repo> [<sha>] reads rollback from 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 new deploy: 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.yaml from the repo's default branch on Forgejo (FORGEJO_URL, FORGEJO_OWNER for a bare <repo>, and FORGEJO_TOKEN; the URL and owner default to the origin remote of the working directory).

    • Target. With no <sha>: the newest deploy: <app>@<short> record (in the repo of live'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.workflow run (the check.jobs, else every job) for that exact sha did not pass, the rule of ship-check-passed.sh.
    • How. redeploy-previous: it dispatches deploy.workflow on the default branch by workflow_dispatch with the input sha (the full sha); the workflow skips its build when inputs.sha is set and calls ship-deploy.sh --sha <inputs.sha>, which writes the new deploy: record. --local --script <ship-deploy.sh> -- <flags> runs the script here instead, adding --app, --sha and the health and version URLs of ship.yaml. command: it runs rollback.command with {sha}, {short_sha} and {tag} filled ({tag}: --tag, else a tag that points at the sha).
    • Wait. Like a deploy: until health.url answers health.expect (or health.command exits 0) and live shows the target (the version URL answers the sha, else the newest record is the sha), up to health.timeout. It exits non-zero when the target is not observed in that time.
    • --dry-run prints the target, the check it read, what it would run and what it would wait for, and changes nothing.
  7. .fleet/ship.yaml in every repo. One file, checked by fleet ship lint in the check workflow (step 2), so a stale file fails the gate.

  8. 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, and Deploy <sha>: <what> in heb-api. One format, one place, makes deploy-commit a 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)

  1. swarm-lab: fleet ship lint and the ship.yaml loader; the Work board reads live from it (this generalises #355's per-project rule: #355's (a) is release, (b) is workflow, (c) is deploy-commit, plus version-url and branch). Until ship.yaml lands, #355's project setting is the stopgap and its values map one to one.
  2. swarm-lab: fleet ship rollback <repo> [<sha>].
  3. swarm-lab: one train per repo (merge-train-<repo>), with the fast-forward-after-check stack of §1 step 3. The train reads merge from ship.yaml. #378 moves the plain merge (one green branch, fast-forward) into fleet serve; the per-repo config is what both the train agent and the server read.
  4. Infra repo: scripts/ship-deploy.sh <app> <short-sha> (sed the image, verify, commit deploy: <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.

  1. CLAUDE.md has a "Ship" section that points to .fleet/ship.yaml and this document.

  2. .forgejo/workflows/ci.yaml runs the full gate on a push to t/**, train/**, the default branch and tags (not wip/**, Q14), and runs fleet ship lint. If it also allows workflow_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.)

  3. .fleet/ship.yaml exists and lints.

  4. 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.

  5. The running service answers /version with its sha, and /healthz.

  6. fleet ship rollback <repo> has been run once against a test deploy and worked.

  7. The repo has a train agent, or merge.mode: direct with 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)