Skip to content

Commit 85ec16e

Browse files
Promote commits to viable/strict on a schedule, not by commit count (pytorch#22064)
# PR pytorch#22064: Promote commits to viable/strict on a schedule, not by commit count ## Problem viable/strict only advanced from commits whose position in main's history happened to be divisible by 4. Every other commit was permanently ineligible, and the manual escape hatch for promoting one did not work, so a commit could sit outside viable/strict indefinitely and miss the nightly build that is cut from it. Two independent reasons the escape hatch did not work: 1. `viable-strict-gate` ran on every push and failed on commits outside the sample. The viable/strict updater reads one row per workflow **run** rather than per workflow, so pushing a `ciflow/trunk` tag afterwards added a second, successful row beside the failed one instead of replacing it. Any single failure is fatal, so the commit stayed ineligible forever. A comment in `promote-to-viable-strict.yml` claimed the updater "resolves multiple runs by taking the latest conclusion", which is not what it does. 2. `promote-to-viable-strict` pushed its tag using the default `GITHUB_TOKEN`. A ref pushed with that token does not start any workflow run, so the tag triggered neither the full CI it was meant to force nor the gate. Counting commits is also the wrong unit. When the repository is busy, four commits can be twenty minutes apart and full CI runs more often than it needs to. When it is quiet, four commits can span two days. Measured over the last two weeks of main, the longest a commit waited to become eligible was **56.7 hours**; over 30 days it was **58.0 hours**. Either is long enough to miss a whole nightly build. ## Changes - `viable-strict-gate` runs only on `ciflow/trunk` tags. A plain push produces no run of it, so the updater reports the required check as missing and declines to advance. The gate never writes a failure row, so it can no longer be the thing that poisons a commit. To be clear about the scope of that: the other five required checks still run on push and can still leave a permanent failure row, so this removes one source of poisoning rather than all of them. - `promote-to-viable-strict` runs every 4 hours and promotes the tip of main. On a scheduled tick it exits without doing anything when viable/strict already contains the commit, and on any run it exits when the tag already exists, so repeated ticks over a quiet period do not re-run CI. One tick sits ahead of the nightly branch cut, so the last commits of a quiet night still reach that day's nightly build. - `promote-to-viable-strict` checks out with a bot token so its tag push actually starts CI, and its `sha` input is now optional and defaults to the tip of main. - Dropped the step that deleted failed gate runs. It could not help: the updater's data comes from webhook events, and deleting a run does not retract the row it already produced. With the gate no longer running on push there is nothing left to delete either. The depth based sample in `_ci-run-decision.yml` is unchanged, and must stay. Seven workflows re-run from a `ciflow/trunk` tag, but only four of them call `_ci-run-decision.yml`. The other seven callers (cuda, cuda-windows, cuda-perf, metal, mlx, rocm, vulkan) have their own ciflow tags but not `ciflow/trunk`, so a promotion tag never starts them, and they hold 32 of the 48 jobs whose `if:` gates on `is-full-run`. Most of those 32 also have a changed-files branch and still run on main when their own paths are touched. The 12 in `mlx.yml` do not, so for those the depth sample is the only thing that ever runs them on main. ## Cost and the alternative that was considered `pull`, `trunk`, `Apple`, `Windows MSVC Build`, `Test RISC-V Backend` and `Test QNN Windows MSVC build` trigger on both a push to main and a `ciflow/trunk` tag, and their concurrency keys differ, so neither run cancels the other. A promoted commit therefore runs those workflows twice. The obvious cheaper alternative is to make `is-full-run` true for the first commit in each 4 hour wall clock window, computed from committer timestamps, instead of every fourth commit by depth. No tag, no new workflow, no token. Measured over main's history: | | full-run events per day | vs today | longest observed wait to become eligible | |---|---|---|---| | today, every 4th commit | 4.14 | 1.00x | 56.7 h | | this PR | 8.21 | 1.98x | 4 h plus CI time | | first commit per 4 h window | 4.07 | 0.98x | 20.2 h | Figures are over 14 days. Over 30 days: 3.30 / 7.30 / 4.00 events per day, 1.00x / 2.21x / 1.21x, and longest observed waits of 58.0 h / 4 h plus CI time / 28.3 h. Three things about that table need saying, because a quick reading of it gets all three wrong. **The alternative does not actually fix the problem.** Its worst observed wait is 20 to 28 hours, not 4, and its true worst case is unbounded. A wall clock window only opens when a commit arrives, so during a quiet night it promotes nothing, which is exactly the case the nightly build cares about. This change promotes the tip of main on a timer whether or not anything new landed, so a commit is eligible one tick after it lands. That is the difference between missing a nightly and not missing one, and it is the reason to prefer this approach despite the cost. **The 4 hours is the cron spacing, not a guarantee.** Add CI wall clock and up to 30 minutes for the next updater tick, and GitHub can delay or drop scheduled runs under load. On the one real promotion tag I could measure, all four required tag-started workflows were green 2.2 hours after the tag, and that figure includes a hand re-run of a cancelled `trunk` attempt, so it is not a clean unattended measurement. The 08:00 UTC tick is about 3.5 hours ahead of the nightly cut, so the margin is real but it is not large. **The cost is worse than the event count suggests, not better.** A promotion tag does not just re-run the jobs gated on `is-full-run`; it starts seven whole workflows over again. Measured on commit `cff6f4dd`, which received a real `ciflow/trunk` tag: the tag run cost 6,046 runner-minutes (latest attempt of each job, skipped jobs excluded), and about 85 percent of that by runner-minutes, 82 percent by job count, repeated work the push to main had already finished. Per event, a promotion is more expensive than a depth sample, not less. Where that lands in absolute terms: roughly 4.07 promotions a day at about 6,000 runner-minutes each is about 24,600 runner-minutes a day added, against roughly 128,000 a day for main CI today. So about **1.19x** on the total main CI bill. That is the honest number, and it is smaller than 1.98x only because full runs are a minority of the bill, not because the added events are cheap. One further cost not in the table: a promoted commit produces roughly twice the job rows the updater must find green, so it roughly doubles the exposure to a flake blocking advancement. If the cost is judged too high, the direction I would look first is not the wall clock alternative but adding `ciflow/trunk/*` to the seven callers that do not listen for it, so that a tag unlocks all 48 gated jobs instead of 16. A rough estimate puts that at about 1.16x against this change's 1.19x, so the saving is real but small, and I have not measured it properly. Note that it would not allow deleting the depth sample: the sample guarantees at most 3 consecutive commits without a full run, whereas promoting only the tip at each tick guarantees nothing within a window. The busiest 4 hour window in the last two weeks held 16 commits. ## Correction to an earlier version of this description An earlier version said `GH_PYTORCHBOT_TOKEN` was not set on this repository and asked for it to be added as a repository secret. That was wrong on both counts. The secret is set. It is an **environment** secret on the `update-commit-hash` environment, alongside `UPDATEBOT_TOKEN`. The real defect was in this change: the promote job did not declare `environment: update-commit-hash`, so it could not read the secret and would have failed on every run. That is now fixed, following the same pattern as `weekly-pytorch-pin-bump.yml`. Adding it as a repository secret would also have been the wrong fix, because a repository secret is readable by any workflow on any ref. The earlier version also said `nightly.yml`, `cherry-pick.yml`, `ghstack_land.yml`, `apple.yml` and `weekly-pytorch-pin-bump.yml` reference unset bot tokens. That was a consequence of the same mistake and is not true. All five are correctly wired: cherry-pick and ghstack_land use `GH_PYTORCHBOT_CHERRY_PICK_TOKEN` on the `cherry-pick-bot` environment, weekly-pytorch-pin-bump uses `UPDATEBOT_TOKEN`, apple.yml falls back to `GITHUB_TOKEN`, and nightly.yml already declares the environment. No action is needed on any of them. ## Test plan Ran the promote script against a real clone with the push and the remote tag lookup stubbed out, covering every branch: - No `sha` input, which is the scheduled path: resolves the tip of main, passes validation and reachability, and stops cleanly on the already existing tag. Exit 0. - A hand dispatched SHA that is already contained in viable/strict: now proceeds to the tag push instead of exiting early. This was a real defect. 13272 of the 13274 first-parent commits on main are already ancestors of viable/strict, so the old behaviour turned nearly every deliberate dispatch into a silent no-op that still reported success. - A malformed SHA, and a well-formed SHA that is not a commit: both rejected with an explicit error before anything is pushed. - All three workflow files parse as YAML and the extracted shell passes `bash -n`. ## Known limitation The `update-commit-hash` environment's deployment branch policy allows `main` only, so the promote job cannot be dispatched from this branch and is first exercised after merge. Everything except the tag push and the secret read is covered by the runs above. --------- Co-authored-by: pytorchbot <pytorchbot@users.noreply.github.com>
1 parent b8b5e0f commit 85ec16e

3 files changed

Lines changed: 143 additions & 86 deletions

File tree

‎.github/workflows/_ci-run-decision.yml‎

Lines changed: 17 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,23 @@ name: CI Run Decision
1414
# - pull_request / pull_request_target (use path filter instead)
1515
# - push events not matching any of the above (path-filtered runs)
1616
#
17-
# See ``viable-strict-gate.yml``: viable/strict only advances on
18-
# commits where this is true, so the path-filtered fast path doesn't
19-
# silently advance partial signal.
17+
# viable/strict eligibility is not decided here. It follows from the
18+
# ``ciflow/trunk`` tag that ``promote-to-viable-strict.yml`` pushes; see
19+
# ``viable-strict-gate.yml``.
20+
#
21+
# Do not assume promotion makes the depth sample redundant. Seven
22+
# workflows list ``ciflow/trunk/*`` under ``on.push.tags`` and so re-run
23+
# from a promotion tag: pull, trunk, apple, windows-msvc, riscv64,
24+
# qnn-windows-msvc and viable-strict-gate. Only four of those call this
25+
# workflow. The other seven callers (cuda, cuda-windows, cuda-perf,
26+
# metal, mlx, rocm, vulkan) do have ciflow tags, but none of them listens
27+
# for ``ciflow/trunk``, so a promotion tag never starts them, and they
28+
# hold 32 of the 48 jobs whose ``if:`` gates on ``is-full-run``. Most of
29+
# those 32 also have a changed-files branch and still run on main when
30+
# their own paths are touched; the 12 in mlx.yml do not, so for those the
31+
# depth sample below is the only thing that runs them automatically on a
32+
# push to main. (``workflow_dispatch`` and ``ciflow/mlx`` can still force
33+
# them by hand, which is not a substitute for running on main.)
2034

2135
on:
2236
workflow_call:
Lines changed: 93 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -1,39 +1,42 @@
11
name: Promote commit to viable/strict
22

3-
# Manual escape hatch for the sampled-CI gating in
4-
# `_ci-run-decision.yml` + `viable-strict-gate.yml`.
3+
# Grants a commit eligibility for viable/strict by pushing a
4+
# `ciflow/trunk/<sha>` tag at it, which:
5+
# 1. Runs `pull.yml` / `trunk.yml` against that commit with
6+
# ``is-full-run = true``, so every gated job runs regardless of the
7+
# path filter.
8+
# 2. Runs `viable-strict-gate.yml`, whose presence is what
9+
# `update-viablestrict` requires before it will advance.
510
#
6-
# Pushes a `ciflow/trunk/<sha>` tag at a chosen commit, which:
7-
# 1. Re-triggers `pull.yml` / `trunk.yml` against that commit with
8-
# ``is-full-run = true`` (every gated job runs regardless of
9-
# path filter or SHA sample).
10-
# 2. Triggers `viable-strict-gate.yml` for that commit; the gate
11-
# succeeds because tag pushes always count as a full-run.
11+
# This runs on a schedule, because landing a commit does not make it
12+
# eligible on its own. Without a periodic promotion the tip of main
13+
# would sit outside viable/strict until somebody promoted it by hand.
1214
#
13-
# Once those tag-triggered runs all pass, the next
14-
# `update-viablestrict` cron run will be able to advance viable/strict
15-
# to the chosen commit.
15+
# The schedule includes a tick several hours before the nightly branch
16+
# is cut, so the last commits of a quiet night still have time to run
17+
# full CI and reach that day's nightly build.
1618
#
17-
# Use cases:
18-
# - Bisecting a regression on a non-sampled commit.
19-
# - Pre-release validation: pin viable/strict to a specific commit
20-
# (e.g. release branch tip) regardless of its SHA's sample bit.
21-
# - Recovering when recent sampled commits all happen to be red.
19+
# Can also be dispatched by hand for a specific commit, for example to
20+
# force full CI on one commit while bisecting a regression. Note that
21+
# promoting a commit that is only on a release branch runs CI for it but
22+
# will never advance viable/strict: the updater only considers commits
23+
# reachable from the branch it checks out, which is main. (The
24+
# `main-branch: main` line in update-viablestrict.yml looks like it
25+
# controls this, but the action does not declare that input and passes a
26+
# hardcoded value, so it has no effect either way.)
2227

2328
on:
29+
schedule:
30+
# Every 4 hours. The 08:00 UTC tick is the one that lands ahead of
31+
# the nightly branch cut.
32+
- cron: "0 0,4,8,12,16,20 * * *"
2433
workflow_dispatch:
2534
inputs:
2635
sha:
27-
description: "Full 40-char SHA on main / release/* to promote"
28-
required: true
36+
description: "Full 40-char SHA on main / release/* to promote. Defaults to the tip of main."
37+
required: false
2938
type: string
3039

31-
permissions:
32-
contents: write
33-
# Needed to delete the failed `viable-strict-gate` run that the
34-
# original push triggered — see the "Delete failed gate runs" step.
35-
actions: write
36-
3740
concurrency:
3841
# One in-flight promotion at a time; safer than racing tag pushes.
3942
group: promote-to-viable-strict
@@ -43,17 +46,57 @@ jobs:
4346
push-ciflow-tag:
4447
if: ${{ github.repository_owner == 'pytorch' }}
4548
runs-on: ubuntu-22.04
49+
# GH_PYTORCHBOT_TOKEN is an environment secret, not a repository
50+
# secret, so a job that does not name the environment cannot read it
51+
# and would see an empty string. Same pattern as
52+
# weekly-pytorch-pin-bump.yml.
53+
#
54+
# This environment's deployment branch policy allows `main` only, so
55+
# a hand dispatch from any other ref is refused before the first
56+
# step. That also means this job cannot be exercised from a pull
57+
# request branch; it is first live after merge.
58+
environment: update-commit-hash
59+
permissions:
60+
# Both the checkout and the tag push use the bot token below, so no
61+
# step uses GITHUB_TOKEN at all. Declared read-only rather than
62+
# omitted so that a future step cannot silently inherit write.
63+
contents: read
4664
steps:
65+
# Checked before the tag is pushed rather than after, so a missing
66+
# secret is reported as itself instead of as an opaque checkout
67+
# error or, worse, a tag that silently starts nothing.
68+
- name: Check the bot token is configured
69+
env:
70+
BOT_TOKEN: ${{ secrets.GH_PYTORCHBOT_TOKEN }}
71+
run: |
72+
set -eu
73+
if [ -z "${BOT_TOKEN:-}" ]; then
74+
echo "::error::GH_PYTORCHBOT_TOKEN resolved to an empty string. It is an environment secret on the 'update-commit-hash' environment, so check that this job still declares that environment and that the secret is still present on it. Promotion needs a bot token with contents write access, because a ref pushed with the default GITHUB_TOKEN does not start any workflow run and the tag would do nothing."
75+
exit 1
76+
fi
77+
4778
- uses: actions/checkout@v4
4879
with:
4980
fetch-depth: 0
81+
# A ref pushed with the default GITHUB_TOKEN does not start any
82+
# workflow run, which would leave the tag below doing nothing.
83+
# Push as the bot so the tag triggers full CI and the gate,
84+
# which is the entire point of promoting a commit.
85+
token: ${{ secrets.GH_PYTORCHBOT_TOKEN }}
5086

5187
- name: Validate SHA and push ciflow tag
5288
env:
53-
SHA: ${{ inputs.sha }}
89+
INPUT_SHA: ${{ inputs.sha }}
5490
run: |
5591
set -euo pipefail
5692
93+
# A scheduled run has no inputs, so promote the tip of main.
94+
SHA="${INPUT_SHA:-}"
95+
if [ -z "$SHA" ]; then
96+
SHA=$(git rev-parse origin/main)
97+
echo "No SHA given; promoting the tip of main: $SHA"
98+
fi
99+
57100
# Reject anything that isn't a full 40-char lowercase hex SHA.
58101
if [[ ! "$SHA" =~ ^[0-9a-f]{40}$ ]]; then
59102
echo "::error::Input must be a full 40-char lowercase hex SHA; got: '$SHA'"
@@ -90,10 +133,25 @@ jobs:
90133
exit 1
91134
fi
92135
136+
# Nothing to promote if viable/strict already contains the
137+
# commit. This is the common case for a scheduled tick that
138+
# finds main unchanged since the last one.
139+
#
140+
# Only applied when we picked the SHA ourselves. Almost all of
141+
# main is already an ancestor of viable/strict, so applying it
142+
# to a hand-dispatched SHA would turn nearly every deliberate
143+
# request into a silent no-op that still reports success.
144+
if [ -z "${INPUT_SHA:-}" ] \
145+
&& git merge-base --is-ancestor "$SHA" origin/viable/strict 2>/dev/null; then
146+
echo "$SHA is already contained in viable/strict; nothing to do."
147+
exit 0
148+
fi
149+
93150
TAG="ciflow/trunk/$SHA"
94151
95-
# If the tag already exists (e.g. someone already promoted
96-
# this commit), exit cleanly — no-op is a valid outcome.
152+
# If the tag already exists (e.g. an earlier tick promoted
153+
# this same commit), exit cleanly. This is what keeps repeated
154+
# ticks over a quiet period from re-running CI.
97155
if git ls-remote --tags --exit-code origin "refs/tags/$TAG" >/dev/null 2>&1; then
98156
echo "Tag $TAG already exists on origin; nothing to do."
99157
exit 0
@@ -104,42 +162,11 @@ jobs:
104162
git tag "$TAG" "$SHA"
105163
git push origin "$TAG"
106164
107-
echo "::notice::Pushed $TAG. Watch the tag-triggered workflow runs (pull / trunk / viable-strict-gate); once they pass, the next update-viablestrict cron (every 30 min) will advance viable/strict."
108-
109-
# Defense-in-depth: the push that originally landed this commit
110-
# triggered a `viable-strict-gate` run that failed (because the
111-
# commit wasn't sampled). The tag push above triggers a NEW run
112-
# of the gate workflow that will succeed. Standard PyTorch viable/
113-
# strict resolves multiple runs by taking the latest conclusion,
114-
# so this is usually fine — but to remove ambiguity (and keep the
115-
# commit's HUD row clean), explicitly delete any prior failed/
116-
# cancelled gate runs on this SHA.
117-
- name: Delete failed viable-strict-gate runs on this SHA
118-
env:
119-
GH_TOKEN: ${{ github.token }}
120-
SHA: ${{ inputs.sha }}
121-
REPO: ${{ github.repository }}
122-
run: |
123-
set -euo pipefail
124-
125-
# List all viable-strict-gate runs for the SHA, filter to
126-
# those that completed unsuccessfully, and delete each one.
127-
# Failures here are non-fatal: the tag push above is the
128-
# primary mechanism; this cleanup is best-effort.
129-
RUNS=$(gh api "repos/$REPO/actions/runs?head_sha=$SHA&per_page=100" \
130-
--jq '.workflow_runs[]
131-
| select(.name == "viable-strict-gate")
132-
| select(.conclusion == "failure" or .conclusion == "cancelled" or .conclusion == "timed_out")
133-
| .id' 2>/dev/null || true)
134-
135-
if [ -z "$RUNS" ]; then
136-
echo "No prior failed viable-strict-gate runs to clean up."
137-
exit 0
138-
fi
139-
140-
while IFS= read -r RUN_ID; do
141-
[ -z "$RUN_ID" ] && continue
142-
echo "Deleting failed viable-strict-gate run $RUN_ID"
143-
gh api -X DELETE "repos/$REPO/actions/runs/$RUN_ID" || \
144-
echo "::warning::Failed to delete run $RUN_ID; continuing anyway."
145-
done <<< "$RUNS"
165+
# Only the workflows that list ciflow/trunk/* under `on.push.tags`
166+
# start from this tag. Four of them are in update-viablestrict's
167+
# required set; the other three run but do not gate. `lint` and
168+
# `Build documentation` are required too, and neither has a
169+
# ciflow/trunk trigger, so their rows come from the earlier push
170+
# to main; if either was cancelled on that push, this tag cannot
171+
# revive it.
172+
echo "::notice::Pushed $TAG. Workflow runs started by this tag: pull, trunk, Apple, viable-strict-gate, Windows MSVC Build, Test RISC-V Backend, Test QNN Windows MSVC build. Of those, update-viablestrict only requires pull, trunk, Apple and viable-strict-gate; the other three do not gate advancement. The two remaining required checks, lint and Build documentation, do not start from a ciflow/trunk tag and must already be green from the push to main. Once all six required checks are green, the next update-viablestrict cron (every 30 min) will advance viable/strict."
Lines changed: 33 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,30 @@
11
name: viable-strict-gate
22

3-
# Sampled-full-run gating for viable/strict advancement.
3+
# Marks a commit as eligible for viable/strict advancement.
44
#
55
# Path filtering on push to main saves runner cost but risks advancing
6-
# viable/strict on commits where many jobs were skipped — a partial
7-
# green from "no job ran" is indistinguishable from "everything passed"
8-
# at the workflow-conclusion level.
6+
# viable/strict on commits where many jobs were skipped: a partial green
7+
# from "no job ran" is indistinguishable from "everything passed" at the
8+
# workflow-conclusion level.
99
#
10-
# This workflow runs on every push to main / release branches and
11-
# *fails* when ``_ci-run-decision.yml`` says this isn't a full-coverage
12-
# commit (i.e. the SHA isn't sampled and there's no ciflow/* tag).
13-
# Failure => the "viable-strict-gate" workflow conclusion is failure
14-
# => update-viablestrict refuses to advance viable/strict.
10+
# So this workflow runs only on ``ciflow/trunk/<sha>`` tags, for which
11+
# ``_ci-run-decision.yml`` always returns ``is-full-run = true``. A plain
12+
# push to main produces no run of this workflow at all, so
13+
# update-viablestrict reports the required check as missing and declines
14+
# to advance. Eligibility is granted by promoting a commit, never by
15+
# landing it. ``promote-to-viable-strict.yml`` pushes those tags, on a
16+
# schedule and on demand.
1517
#
16-
# To force a full run on a specific commit (e.g. before tagging a
17-
# release), push a ``ciflow/trunk/<sha>`` tag — on tag pushes
18-
# ``_ci-run-decision.yml`` always returns ``is-full-run = true``.
18+
# This workflow used to run on every push and fail on commits outside
19+
# the sample. That wrote a permanent failure: the viable/strict updater
20+
# reads one row per workflow *run* rather than per workflow, so a later
21+
# successful run sat beside the failed one instead of replacing it, and
22+
# a single failure anywhere is fatal. A commit that landed outside the
23+
# sample could therefore never be promoted afterwards. Producing no run
24+
# at all avoids that, because there is nothing to sit beside.
1925

2026
on:
2127
push:
22-
branches:
23-
- main
24-
- release/*
2528
tags:
2629
- ciflow/trunk/*
2730

@@ -37,6 +40,20 @@ jobs:
3740
name: Full CI required for viable/strict
3841
runs-on: ubuntu-22.04
3942
steps:
43+
# Only tag pushes reach this workflow, so is-full-run is always
44+
# true here. Kept as an assertion against a future trigger that
45+
# does not force a full run.
46+
#
47+
# Failing is the correct behaviour for a tag push, which is a
48+
# deliberate request, but it is NOT a safe way to reject ordinary
49+
# commits: a failure row here is permanent, for the reason in the
50+
# header. So do not re-add ``push: branches`` above. Adding
51+
# ``workflow_dispatch`` is a different trap: it would make this
52+
# assertion pass and publish a viable-strict-gate success for a
53+
# commit whose CI was path-filtered. ``schedule`` is unsafe for the
54+
# opposite reason: ``_ci-run-decision.yml`` returns false for a
55+
# schedule event, so every tick would fail here and write a
56+
# permanent failure row on the tip of main.
4057
- name: Check whether this commit is a full-coverage run
4158
env:
4259
IS_FULL_RUN: ${{ needs.run-decision.outputs.is-full-run }}
@@ -47,6 +64,5 @@ jobs:
4764
exit 0
4865
fi
4966
echo "::error::Non-full-run commit (path-filtered CI). viable/strict cannot advance from this commit."
50-
echo "Full CI runs on every 4th commit on main / release/* (depth %% 4 == 0)."
51-
echo "To force a full run on this commit, push a 'ciflow/trunk/${{ github.sha }}' tag."
67+
echo "This workflow should only ever run on a 'ciflow/trunk/<sha>' tag, which always forces a full run."
5268
exit 1

0 commit comments

Comments
 (0)