cloud · collections · salesforce16 Nov 2026 · staging

One command releases staging.
The API is live in 6m12s.

One command cuts every line that moved, releases the green head of develop beside those cuts, and lands the pins afterwards. This page explains what runs, in which order, and where the minutes go.

Batch 4, step by step16 Nov 11:25 to 11:49 UTCmeasured
APIengineopsconnectorpin pull request
The API Worker served api-v0.3.170 at 6m12s, before any pin landed. The cycle then ran one step at a time and finished at 23m27s. Hover a bar for its workflow run.
At a glancefirst batch of the day → fourth

The API no longer waits for the cycle, and nothing inside its release rolls a Container out.

Before is the first batch of 16 Nov 2026 (api-v0.3.167, 18m13s). After is the fourth (api-v0.3.170, 6m12s), run with engine 0.56.1 after every lane of the day had merged. Each figure comes from the batch's own summary line or the Actions run it names, and the two marked by design hold because of the merged declarations.

API live on staging measured
18m13s→6m12s−66%
from the command's start to the health gate passing, batch 1 → batch 4
A fix merged to develop reaches staging in about six minutes when no migration is pending.
Steps that gate the API by design
whole cycle→its own two
cloud #950: lock-only pin moves release the green head first
The bundle and the release are the only steps between the command and the live Worker.
Container rollout inside the API release measured
3m49s→0s−100%
the connector line rolls its own Container out since cloud #951, #954 and salesforce #376
A bad connector image is caught on its own line, held at one instance, and never reaches the API release.
Cycle complete measured
18m13s→23m27s+29%
engine cut, salesforce pin, connector, connector rebind, collections pin, in series
Staging is current throughout; the longer tail only delays the pin commits and the connector swap.
Lineswhat one batch moves

Six lines, one plan, and the API released beside the cuts.

The command reads every line against its newest release, decides which to cut, and writes one plan: tag lines, pin pull requests and the API release, each step waiting only on what it needs.

6
lines the cycle reads
framework, engine, evidence, ops, connector, api
7
steps in batch 4
5 waves · 3 steps together in wave 1
2
pin pull requests
salesforce #378 · collections #2713
3
lines cut
engine 0.56.2 · ops 0.25.3 · connector 0.26.3
Each line, and what moves itcloud/oc.yml on cloud main, collections develop and salesforce mainby design
LineRepository and branchCut whenWhat the cut producesWho pins it
frameworkframework, mainmain holds commits past its newest releasea TypeScript and a Go package at one versioncollections (catalogue entry and Go requires)
enginecloud, mainmain holds commits past its newest releasecloud-cli-vX.Y.Z: the oc binary and the engine image that release.yml runssalesforce and collections (cloud/oc.lock)
evidencecloud, maincommits past its release that are not under ignorethe sealed evidence bundlenobody; sealed and attested only
opssalesforce, maincommits past its release that are not under ignorethe salesforce ops image for oc salesforcecollections (cloud/salesforce.lock)
connectorsalesforce, maincommits past its release, or its pins moveconnector-vX.Y.Z: the Container image, rolled out on its own linethe API binds the newest healthy one at release time
apicollections, developevery batchapi-vX.Y.Z: three Workers and the migrate Container on stagingnone; it is the target
Reading: a line whose commits are all under ignore is held; a breaking change stops the plan until --version line=X.Y.Z names the version.
The plan's four rulesoc release staging --help, engine 0.56.2by design

A step starts once the steps it waits on have passed. Steps with no such wait run together, so the engine cut, the ops cut and the API release shared wave 1.

Never two steps that deploy the same Worker. The API release and the connector rebind lock the three staging Workers, so they never overlap.

A failure starts no further step. Running the command again resumes from the step that stopped, re-planned on the newest heads.

Lock-only pin moves release the green head first. When the pins change only lock files and develop's head is green on trusted CI, the head is released at once beside the cycle; the pin pull request lands after it. A code change in the pins, a head not yet green or --serial keeps the pins first.

Batch 4's plan, as the command printed itdry run, 16 Nov 11:25 UTCmeasured
WaveStepWaits on
1engine: tag cloud-cli-v0.56.2 once ci.yml passes on mainnothing
1ops: tag ops-v0.25.3 once ci.yml's gate job passesnothing
1api: release develop's head as api-v0.3.170 before its pins landnothing
2salesforce: one pull request moving engine 0.56.1 → 0.56.2, merged on greenengine
3connector: release connector-v0.26.3 from that mergesalesforce pin
4api: roll the connector Worker out on the same head, binding connector-v0.26.3connector, api
5collections: one pull request moving engine and ops, merged on greenengine, ops, both api steps
Reading: everything after wave 1 is a chain, which is why the cycle outlasts the API by seventeen minutes.
Cyclefour batches on 16 Nov 2026

The API target is met; the cycle is now a serial chain behind it.

Each batch below was run from this laptop with the engine the collections lock pinned at the time. The third ran with an engine that lacked the own-line-first rule, and shows what the rule removes.

API live and cycle complete, per batchsummary line of each batch logmeasured
API livecycle complete
Reading: in batches 1 to 3 the API waited for the whole cycle, so both bars are one. Batch 4 is the first where the API's own time is visible.
Where batch 4's minutes wentbatch-4.log summary and the Actions runs it namesmeasured
StageMeasuredInside itOn the API path
API live: bundle, then release.yml6m12sbundle 2m12s · release 2m59s (gate 14s, rollout 55s, connector Container kept)yes
Engine cut7m21sci.yml 3m22s (the push run, already running) · release-cli.yml 3m36sno, beside it
Salesforce pin pull request1m13sopened, merged four seconds laterno
Connector line8m12sci.yml 1m43s · bundle 3m01s · release 3m12s, its own Container rollout 1m30sno
Connector rebind on the API head (api-v0.3.171)4m51sbundle rebuilt 1m31s · release 2m51s, rollout 23s, no API Worker deployno
Collections pin pull request1m08sengine 0.56.2 and ops 0.25.3, merged four seconds after openingno
Cycle complete23m27sengine → salesforce pin → connector → rebind → collections pin 
Reading: the ops cut (1m31s) ran beside wave 1 and cost nothing. Every other stage after the API waits for the one before it.
What the first batch spent, and which lane removed itbatch.log, 16 Nov 05:27 UTC, api-v0.3.167measured
Cost on the API path in batch 1ThenBatch 4Removed by
Plan, ops gate, tag, pin pull request merge before the API could start2m36s0cloud #950: lock-only pins no longer gate the API
Trusted CI queued behind the previous develop push2m02s0cloud #950: the pin commit's CI runs beside the release
Trusted CI on a pin-only commit, every tier4m01s0collections #2706: pins class runs static and bundle tiers only
Product bundle: stale early run, queue, then the release's own2m28s2m12scloud #949 cancels the stale run; collections #2707 predicts the connector the release will bind
Connector Container rollout inside the API release3m49s0cloud #951, #954 and salesforce #376: the connector line rolls its own Container out
Guard, plan, Workers, health, journal3m14s2m59shealth no longer waits for the maintenance tick once no Container restarts
Reading: the gap between 18m13s and 6m12s is these six rows; the bundle and the release run are what remains.
Graphrelease.yml in cloud, from the sealed bundle

A release runs its target and everything the target requires.

Trusted CI publishes an attested bundle for every develop commit. The release seals it, hands it to cloud's release.yml, and the engine walks the deployable's graph from the target backwards. A node outside that closure never runs, which is what the guard in cloud #955 now refuses for anything but a health gate.

collections/api, target api.healthcloud/oc.yml on develop 89eedd9e3by design
Reading: solid boxes are the target's closure, in the order the engine runs them. The dashed health gate requires the connector Worker but nothing requires it, so it runs only as the Container rollout's step gate and in oc release probe.
salesforce/connector, target connector.healthcloud/oc.yml on main 4561ea6cby design
Reading: the connector line pushes its image, rolls the Container application out in two steps, 25% then 100%, and holds after each until every box links. The API release that follows finds the image current and keeps the running instances.
Each node kind, what it proves, and what it cost in batch 4cloud/oc.yml comments; release run 420056767measured
NodeKindWhat it doesBatch 4
api.store, api.connector-storestoreverifies every Secrets Store reference the Worker binds; a release never creates oneseconds
api.imageimagecopies the attested migrate image to Cloudflare under the release's tagseconds
api.migrate-workerworkerdeploys the migrate Worker, whose Container rolls out with itseconds
api.migrationmigrationasks the ledger what is applied; when nothing is pending no workflow starts, otherwise it waits for the Container on the new image and runs the filesnothing pending
api.connector-workerworkerdeploys the connector Worker and pins the Container image the bundle nameskept
api.workerworkeruploads the API Worker without traffic, proves it at 0% through a version header, then moves all traffic to itabout 30s
api.worker-healthhealththe rollout's gate: /ready pinned to the new version, 90s budget, so a failing version switches back fastseconds
api.healthhealththe target: both Workers ready, every box linked and maintained, 900s budget for a cold start9s
Reading: the whole graph ran in 55s after a 14s guard. The same graph with two pending migrations took 7m12s in batch 3, almost all of it the migrate Container restarting on its new image.
Commandsengine 0.56.2, pinned by collections

One command for the batch, and three ways to narrow it.

Every variant runs the same plan; the flags decide how much of the cycle it takes with it. Nothing runs on the laptop but gh: the workflows do the work, and the command follows them.

CommandWhat it doesWhen
oc release staging --batch --no-tail --waitthe full cycle: cuts every line that moved, merges each pin pull request as it passes, answers the one question, waits for trusted CI, releases develop's headthe routine release; exits in seconds when nothing moved
oc release staging --batch --dry-runprints the cycle and the release with every blocked step marked and numbers what to fix; dispatches nothingbefore every batch
oc release staging --no-upstream --yes --wait --no-tailskips the cycle and releases develop's green head alone, reusing the early bundle trusted CI already publishedthe hotfix lane; api-v0.3.163 ran release.yml in 2m59s
oc release staging --batch --only engine --version engine=X.Y.Zcuts one line in isolation at a named version; no pin pull request opensa sealer floor raise, which needs the engine at exactly that version first
oc release proberuns the checkout's health gate against staging without releasingafter a rollback, or to read the connector's link state
Before any of them: the local oc must be the version collections' cloud/oc.lock pins (0.56.2 today). Batch 3 ran with 0.55.0 and waited for the whole cycle, 33m32s.
Plan

Seven steps in five waves, then what is left to decide.

Pick a wave to see its steps as batch 4 ran them, each with what ran it, its measured time and the condition that closed it. The last picker holds the lanes not yet opened.

Risks and gapsbusiness impact first

What can still go wrong.

Ordered by severity. Each risk states the number behind it, what it means for the business, and where the evidence lives. Pick a severity to narrow the list.

Change logpull requests behind this page

Every change, what, why, how and where.

Every pull request of the release-speed day, newest first, each linking to its pull request and naming the release that carries it. The tabs pick a part of the flow; each entry's own tabs switch between what changed, why, how and where.

Repository
Show in every entry