Release
How finished work reaches develop and then production: an Epic's release pull request, the release train, the release tower (one release at a time), releases that start themselves, /devstride:release, Seed's deploys, the post-deploy check, and how to tell whether a commit is live.
On this page
- Release
- Why develop is treated as production
- The path at a glance
- Release an Epic onto the release train
- Which branches may merge into develop: the merge-path check
- One path to production
- One-offs ride the release train
- One release at a time: the release tower
- Releases start themselves
- Promote to production: /devstride:release
- How Seed deploys
- Is this commit live?
- The post-deploy check
- A deliberate redeploy: ds seed deploy
- Hotfixes
- When something goes wrong
Release#
On this page you will follow finished work the rest of the way: from an Epic's branch or the release train into develop, from develop into a production release, and then check that production is running it and is healthy.
Why develop is treated as production#
develop is cut into a production release several times a day, and merging a release into master deploys production automatically. Whatever is on develop when the next release is cut goes to customers, usually within hours. There is no quiet period in which to finish or tidy something up.
So nothing merges into develop unless it is complete and safe to go live that afternoon. That is why Stories collect on their Epic's own branch, where they are allowed to be unfinished, and only a finished, fully reviewed Epic merges into develop. Before an Epic merges:
- Nothing it deploys may point at something missing. A stack that names a handler, file or resource that does not exist fails the deploy and blocks the pipeline for everyone, not just the author.
- New infrastructure that costs money or changes behaviour is agreed with the owner first (the owner is the person who decides what reaches production). It is never a note someone finds later in production or in a bill.
- Every change a user can see is safe to be live at once, and you can say who it reaches on day one and what, if anything, gates it.
- Database migrations are safe while old and new code run side by side, because a deploy rolls out gradually. Deployment explains how Seed (the hosted service that deploys this application) runs them.
How DevStride Is Built, and Why tells the story behind these rules.
The path at a glance#
Story ─ merge ─▶ its Epic's branch ─ Epic release pull request ─▶ train/release
One-off ─ merge ─▶ train/release
train/release ─ train pull request, at each release ─▶ develop
develop ─ cut ──▶ release/YY-MM-DD ─ release pull request + owner's yes ─▶ master
▲ (or the owner's standing yes)
└─ the release clearance is held from the cut to the confirmed deploy: one release at a time
There is one release train, train/release: finished Epics and one-offs both collect on it, and every release carries it into develop first. Until November 4, 2026 one-offs had a train of their own, the support train (train/support); it is retired, and the merge guard refuses a push that would re-create it.
Seed deploys every merge into develop to the dev stage (a stage is a separate, fully deployed copy of the application), and every merge into master to production.
Release an Epic onto the release train#
An Epic's Stories merge onto its integration branch (named <you>/<YY-MM-DD>/epic-<I#####>-<slug>, where I##### is the Epic's item number) without pull requests of their own; Develop covers that part. When the last one lands:
- The loop reports the Epic release-ready, and asks the owner. In this repository
epicIntegrationBranches.autoReleaseis"ask"in.claude/ds-config.json(the owner's decision of October 16, 2026; it wasfalsebefore), so when an Epic's last Story lands the loop asks the owner, once per Epic, whether to release it, and cuts nothing until they answer. In a run with nobody to answer, it stops at release-ready exactly asfalsewould. - It brings the Epic's branch up to date. It merges the latest
developinto the branch: a merge, never a rebase, because the branch's commits are already shared on GitHub. - It opens the Epic's release pull request into the release train as a draft, through
/devstride:pr(epicIntegrationBranches.releaseTargetistrain/release). The description leads with the Epic and lists its Stories. - Everything gets a full review. Claude's adversarial review (one that sets out to find what is wrong) and the Codex command-line reviewer (a second, independent reviewer that runs on the same machine) go over the whole Epic's changes, every Story included. It is the first and only full review this code gets, because each Story merged after only a short risk check (the quick review a Story gets before it merges), and the train's later pull request into
developdoes not review it again. Every finding is checked, then fixed or dismissed with a reason, and every review thread is answered and resolved. Two rounds is the normal target; a confirmed serious problem keeps review going until a round finds none. - It merges onto the train. The Epic's branch is deleted, the release pull request is linked back onto the Epic and its Stories, and the Stories are marked Done. With releases starting themselves, this merge also starts the next release.
- The next release carries it to
develop. The train's pull request intodevelopruns the one cloud test run the Epic gets (the backend test suite, the linters and the UI tests), and its review covers only the one-offs on the train that no pull request has reviewed.
Leave a ready pull request alone
Once a pull request is marked ready, do not push to it and do not edit its title or description: either one starts its checks again, and a test run already in progress starts over. Finish the wording while it is still a draft.
Which branches may merge into develop: the merge-path check#
develop reaches production at the next release, so only branches that have been through a full review may merge into it. The required merge-path check admits these heads, and nothing else:
| Head branch | What it is |
|---|---|
<you>/<YY-MM-DD>/epic-<I#####>-<slug> |
an Epic's integration branch |
train/release, or the snapshot a release cuts from it |
the release train (below) |
| a master-into-develop sync branch | the close-out of a release, below |
release/… |
a release branch |
<you>/hotfix/… |
a hotfix branch |
dependabot/… |
a Dependabot dependency update |
The rules are mergePath.allowedHeadPatterns in .claude/ds-config.json. The check runs on drafts too, and reads its rules from develop itself, so a pull request cannot loosen its own gate.
Any other head fails unless the pull request carries the merge-path-override label. That is for a change that must ship on its own pull request (deploy configuration or migrations, below) or an Epic branch named before the epic- marker existed. Nothing adds the label for you:
gh pr edit <number> --add-label merge-path-override
To know before you open the pull request, run the same checker locally. It prints ALLOWED or BLOCKED with the reason:
ds merge-path check --head <branch> --base develop
ds merge-path check --head <branch> --base develop --labels merge-path-override
See Command Reference: ds merge-path.
One path to production#
Finished work goes to exactly one place: its Epic's branch, or the release train for a one-off. There are no dated package branches ("evening", "overnight") gathering work for a later release. Why: on November 6, 2026 two were cut by accident, and the work on them waited hours behind the train instead of riding it.
- Epics are small and stand alone. Each can release by itself, so none waits for a sibling and no single Epic holds the train for most of a day. A plan whose Epic would carry many Stories splits it into stand-alone Epics.
- Landing part of a feature switched off is rare. It is allowed only where a stored product setting already exists to switch it, never for a migration or a retirement, and it gets the full review when it lands.
- Some releases go out alone. A release carrying a migration that needs a production checkpoint, or a destructive step (dropping or renaming something customers or read-only database users still call), goes out by itself, at a time agreed with the owner, after any notice the owner owes.
One-offs ride the release train#
A one-off is a Story or Defect outside any plan, usually made with /devstride:create-story or /devstride:create-defect: it has no [N] number and no dependency links. Even when it is filed under an Epic, it never goes on that Epic's branch (with ds work start, pass --one-off for one filed under an Epic). It does not get a pull request of its own. A large one-off (more than 5 files or 500 changed lines, or anything on the high-risk list: sign-in, permissions, billing, the public API, migrations, infrastructure) first gets the full Claude and Codex review on its branch, as an Epic's release does; the plugin does not enforce this yet, so the session landing it runs that review before ds work land. After a short risk check and a green ds verify land (the landing check every item passes), it merges onto the release train, the long-lived branch train/release. Then:
-
It stays open, not Done, with a comment saying it ships with the next release.
-
At the start of every release, the train goes into
developfirst./devstride:releasetakes a snapshot of the train (the live train keeps accepting one-offs) and opens a pull request from it intodevelop. That pull request gets the full Claude and Codex review over the whole train, thelocal-cicheck and one CI run: the one-offs' first full review. It merges before the release is cut. You usually do not start that release yourself: landing a one-off on the train starts the next release by itself.A release is frozen at its cut. What is on the train when its review starts is the release. A one-off that lands while that review is running joins it only if the owner says so; otherwise it ships with the next release, which starts itself straight after (
releaseTrain.lateArrivalsis"offer"in.claude/ds-config.json). Before November 4, 2026 a late one-off restarted the train's review, and on that day held one release back for about eight hours. -
Every one-off it carried is marked Done, with a comment naming the release.
-
The train is brought up to date with
developstraight after its pull request merges, and again when the release closes out. The release does this for you;ds work train rotatedoes it by hand once a release has carried everything on the train.
To see what is waiting, run ds work train status. It lists the one-offs on the train that have not reached develop yet, and changes nothing.
Deploy configuration and migrations never ride the train. A one-off that changes stacks/, sst.config.ts or the database migrations under backend/src/libs/infrastructure/database/migrations/ would reach production soon after the train merges. Instead it ships to develop by its own pull request, so the dev stage deploys it before any release carries it. The delivery loop routes such a change this way by itself; by hand, start it with ds work start <I#####> --infra and open its pull request with /devstride:pr. Either way, nothing adds the merge-path-override label for you: add it with gh pr edit <number> --add-label merge-path-override. The pull request then gets the full review and local-ci like any other pull request into develop. Develop has the commands in context.
One release at a time: the release tower#
Several machines, people and agent sessions release this repository. Two releases in flight at once collide: racing CI runs, review fixes pushed onto a branch someone else is finishing, two merges into master within minutes. So only one production release may be in flight at a time, across every machine and account. Because a release ships everything on develop at the cut, there is never a reason for two: if one is already running, yours waits, and the next release carries your work.
That one release holds the release clearance, from the moment it cuts its release branch until its production deploy is confirmed. The clearance lives on GitHub, so every machine sees the same one, and two machines can never both win it.
See who holds it#
-
At session start, the banner every Claude Code and Codex session prints includes a
Tower:line:Tower: clear, or the release branch, its pull request, who holds it and on which machine, its phase and how long since it last checked in.Tower: unknownmeans the clearance could not be read (usuallyghis not signed in); it never means clear. -
At any moment, from the repository's root:
ds tower statusIt prints the holder, the release pull request that is on final (allowed to merge next), any that are waiting behind it, and any hotfix that reached
mastersince the release started.ds fleet statusopens with the sameTower:line.
The release claims it for you#
/devstride:release merges the release train into develop (its review and its one cloud test run) without the clearance, and claims it just before it cuts the release branch. If another release holds it, the command says who and waits, and carries on the moment it is free. While it works it records each phase (cut, pull request, review, pre-ship, merging, deploy, close-out). It hands the clearance back as soon as the deploy is confirmed, develop contains master, the release branch is deleted and the release train is level, so the next release can start. (This is release.clearance.scope: "cut-to-deploy" in .claude/ds-config.json, since November 4, 2026. Before, a release claimed the clearance before the train and held it through the post-deploy check, so the next release's train review could not start until the previous release had fully settled.)
The post-deploy check then runs after the hand-back, as the first item still owed, and records its result on the production merge commit as the release/post-deploy commit status, which every machine can read. The next release cannot merge into master until that status is success, unless the owner overrides it in words recorded on the pull request. It can still cut, be reviewed and run its checks meanwhile, and a hotfix is never held by it. A session that stopped after the hand-back leaves the status pending; any session finishes it with /devstride:release post-deploy only.
The documentation update, owed customer replies, local teardown and any release note follow in the same session; until each is done, ds tower status on that machine lists it under Close-out owed. A release waiting for the owner's go-ahead keeps the clearance. You do not run anything by hand for a normal release.
Doing a release step by hand, outside /devstride:release? Take the clearance first, and hand it back when you are done:
ds tower claim --purpose release # or --wait to queue behind a release in flight
ds tower release # once production is healthy and the branch work is done
Command Reference: ds tower lists every command.
What is refused without it#
The merge guard refuses three release steps in any Claude Code or Codex session that does not hold the clearance, and says who does hold it:
- a push to a
release/…branch (the cut, or a review fix on it); - opening a pull request into
masterfrom a release branch; - merging a release pull request into
master.
Any other branch opening a pull request into master is told to retarget at develop instead. Claiming the clearance is never the fix for that.
Nothing ever holds up a hotfix. A <you>/hotfix/… branch pushes, opens its pull request into master and merges without the clearance, even while a release holds it. The release learns the hotfix landed (ds tower status lists it) and merges master into its own branch before it merges.
The release-tower check on GitHub#
Every pull request into master gets a release-tower check:
| The pull request's branch | Result |
|---|---|
a hotfix branch (*/hotfix/**) |
passes, always |
| the oldest open release pull request (the lowest number) | passes: it is on final |
| a later release pull request | fails: "<branch> (#n) is on final; this release waits". It turns green by itself when the one ahead merges or closes. |
| any other branch | fails, with the command to retarget it at develop |
any branch carrying the release-tower-override label |
passes: an exception the owner approved by hand |
The check reads its rules from develop, so a pull request cannot loosen its own gate, and it takes seconds. Today it is advisory: it reports, but a red result does not stop a merge. Once the owner makes it a required check on master, a later release pull request cannot merge until the one ahead of it has. Repository administrators can still bypass master's rules.
Only the owner adds release-tower-override. GitHub lets anyone with write access add a label, so the rule holds only because people keep to it.
If a clearance is stale#
A clearance whose release has not checked in for 20 minutes is stale: usually its session crashed or was closed. What happens next depends on how far that release got:
- It never opened a pull request, or its pull request was closed without merging: the next release takes the clearance over by itself, and says so.
- Its pull request is still open, or it merged but never finished its close-out: the next
/devstride:releasestops and asks the owner whether to adopt it and resume where it stopped. It is never deleted silently.
A release that is still checking in but has sat in one phase longer than its budget (release.clearance.phaseBudgetMinutes in .claude/ds-config.json: pre-ship 120, deploy 30, close-out 15 minutes) shows as STUCK, naming its machine and session. That is a signal for the owner, never a takeover: it is adopted only on the owner's yes and their word that its session has stopped (ds tower adopt --yes --original-stopped).
Before the release tower#
Until October 19, 2026 nothing stopped a second release. A session on one machine could cut a release while another machine's release was still in review, and neither would notice until their CI runs and merges collided.
Releases start themselves#
Since November 4, 2026 nobody has to remember to start a release (release.autoStart.enabled in .claude/ds-config.json). Three moments start the next one, in the session where they happen:
- a one-off landing on the release train;
- an Epic's release pull request merging onto the train;
- a release finishing its close-out.
At each, the session checks whether the train holds work that develop does not. If it does, it claims the train claim, a one-winner claim held in DevStride (kind release-train, keyed by the repository, lapsing after 30 minutes without a check-in), and runs /devstride:release. Exactly one session on one machine wins it; a session that loses carries on with its own work and logs nothing. Every release takes the same claim before it opens or adopts the train's pull request, whether someone started it by hand or not, and hands it on once its release branch is cut, so the next release's train review can run while this one deploys. There is never a second release in flight at once and no timer that waits to batch work: each release carries whatever landed during the one before. The hourly machine check never starts one.
The standing yes for light releases#
A light release is one that changes no database migration or schema, no infrastructure and no golden generator (release.lightRelease.disqualifyingPaths; the ds-release-classify skill decides, and anything it cannot decide counts as full). The owner has given a standing yes for those (release.lightRelease.standingYes): a light release merges into master, and has its production deploy approved, without anyone being asked at that moment, when all of these hold:
- its code is identical to the release train that was fully reviewed on its way into
develop; - every required check is green and no review thread is unresolved;
- every local release check passed and none was waived, and the production pre-merge check is clear;
- the dev stage has finished deploying it;
- the previous release's post-deploy check is green;
- it is on final in the release tower.
The release then leaves one comment on its pull request saying it merged on the standing yes. A light release that fails any condition waits for the owner: it stops at the go-ahead holding the clearance, exactly as before, and a release that started itself sends one notification saying what it is waiting for.
The standing yes for full releases#
Since November 7, 2026 the owner's standing yes covers full releases too (release.fullRelease.standingYes, devstride plugin 3.37.0). A full release merges into master, and has its production deploy approved, without anyone being asked at that moment, when every condition above holds (its code is exactly what was reviewed, or review's same-code re-trigger commit, rather than identical to the train) and every migration it adds or changes has been approved by the owner by its content.
- What counts as a migration is the list in
release.fullRelease.migrationGlobs: the SQL migration files, the data-rewrite campaigns, the index and constraint builders the deploy runs, and the migration runner itself. - An approval names one exact file content (its git blob id) in
release.fullRelease.approvedMigrations, and is added only on the owner's own words, in a commit of its own. Renumbering a migration keeps its approval; any edit to its content needs a new one. - Everything else still waits for the owner: a new, edited or deleted migration that has not been approved, a waived local check, a pre-merge hold, or any other failed condition.
Promote to production: /devstride:release#
The owner decides what reaches production. Running the command, or a release starting itself, prepares a release; neither counts as permission to deploy. The only merges without an in-the-moment yes are releases under the owner's standing yes: light releases, and full releases whose migrations the owner approved.
Run it from a leased wt1 or wt2 checkout (see Develop), never the main checkout, and keep the lease until the release's very last step hands the checkout back.
/devstride:release
- It reads what is happening first, and claims the train. It fetches, reads what other people and sessions landed on
developandmasterin the last few hours, and takes the train claim. - It merges the release train into
develop, as above. While the train's cloud tests run, the full golden dataset suite runs on the train's snapshot in the background, when the release touches what that suite tests; a red result stops the train merge. When the release needs a full rebuild of the demo dataset (about two hours), that build also starts now, in the background in the main checkout, if main is free; the release then finds it ready at step 6 instead of starting it there. When main is in use, the build runs at step 6 as before. - It works out what ships: the Epics and items in
developthat are not yet inmaster, and which of them a user would notice. - It claims the release clearance and cuts the release branch
release/YY-MM-DDfromdevelop(with-2,-3added when a release is re-cut), waiting for the clearance when another release holds it. It opens the release pull request from the branch intomasteras a draft, and hands the train claim on, so the next release's train phase can start.developkeeps accepting merges meanwhile; they ship in the next release. - Full review of the release. Claude and Codex. No cloud reviewer is requested: GitHub Copilot left the review loop on October 14, 2026.
- Release-only local checks. The full golden dataset suite (about 28 minutes) runs when the release touches what it tests (backend source, the golden suites, the test harness or the dependencies), once per exact version of the code across every machine: a pass is recorded in DevStride against that exact code, so the release passes this check at once when its code is identical to the train snapshot tested in step 2, or to code any other machine already passed. A machine that arrives while another is still running the suite on the same code waits for that run instead of starting a second one.
ds verify golden-receipt read --tree <tree>shows the recorded result for a version of the code. The golden source readiness check,ds golden release check, runs too: the release will not go ahead without a prepared, certified copy of the demo dataset for exactly the code being released. A release that changes no database migration or schema, no infrastructure and no golden generator skips this one check, because the production deploy's own refresh of the golden source covers it. The Golden Dataset page explains the golden source. Last, as close to the merge as possible, the AWS sign-ins the release needs after the merge, production's and this machine's own stage's, must have at least two hours left; the check runs again just before the merge when the owner's go-ahead comes long after it passed. If either sign-in falls short, the release stops and names theaws sso login --profile <profile>command to run, rather than reaching production and then waiting on a lapsed sign-in; a machine's certificate identity has nothing to expire and passes. - Cloud CI runs once, when the pull request is marked ready: the backend test suite, the linters and the UI tests. The push to
masterthat lands the release reuses this green run when the code is identical, so the suite does not run twice. - It stops and asks the owner, unless the release qualifies for the standing yes, light or full. Before either, it checks the previous release's post-deploy result: no release merges into
masteruntil that result is green. The summary leads with READY or BLOCKED and lists every change in plain words, each local check's result, the documentation plan, whether a release note will be written, and what merging triggers, quoted fromrelease.autoDeployOnMerge: "Merging to master auto-deploys production via SEED (seed.run) — no manual deploy step." - It merges only on the owner's explicit yes, or the standing yes, with a merge commit.
- It confirms the deploy. Production has no address that reports which version it runs, so the release first asks the owner to confirm the deploy has finished.
- It finishes the branch work and hands the clearance back. It waits for the automatic pull request that merges
masterback intodevelop(or findsdevelopalready containsmaster), so fixes made on the release branch reachdevelop. It deletes the release branch once both branches contain it, and brings the release train up to date. Then it hands the release clearance back, so a waiting release can cut. - It checks production, with the post-deploy check below, and records the result as the
release/post-deploystatus on the merge commit. FAIL stops the release and puts a rollback decision to the owner; nothing public is written about a release that might be rolled back, and the next release cannot merge until it is resolved. - It updates the documentation. The repository's
ds-update-docsskill brings docs.devstride.com in line with what shipped, by default, only once the deploy is confirmed live and healthy. Addno docsto the command to skip it. - It closes out. It posts the customer replies owed for the items that shipped and tears down the release's local resources. Then it checks the train again, and starts the next release if work is waiting.
- It writes a release note only when asked:
/devstride:release --release-notespublishes one after the deploy is confirmed, and--release-notes draftleaves it for the owner to read first. Nothing in the loop decides on its own that a release deserves a note; the owner does. Steps 12 to 15 run after the hand-back, in the same session, one after another; until each is done,ds tower statuson that machine lists it underClose-out owed.
A release branch is protected. Fixes found during review are new commits on it, never a rebase or force-push; GitHub refuses a force-push to any release/* branch. A fix that touches deploy configuration or migrations is refused there: merge it into develop through a normal pull request, abandon the release branch, and run /devstride:release again to re-cut. If a hotfix reaches master while a release is open, the release merges master into its branch and reviews it again, and asks the owner again.
The Delivery Loop: Production release has the full mechanics, and Configuration Reference: Production release has the settings.
How Seed deploys#
Seed (seed.run), a hosted deploy service, deploys this application. A merge into develop deploys the dev stage (app.devstride.dev), and a merge into master deploys production, the prod stage (app.devstride.com). GitHub Actions deploy nothing, and there is no deploy step to run by hand: merging is the deploy.
During each deploy Seed runs the additive migrations before the new code goes live and the tightening ones after it. Deployment explains this and the checks that run in GitHub Actions. An ordinary production deploy took about seventeen minutes from start to finish when it was measured.
Is this commit live?#
Seed writes a GitHub deployment record for every commit it deploys, under the environment prod or dev, created by its own GitHub account, seed-deploy[bot]. Read those records with gh, the GitHub command-line tool; it needs to be signed in.
To see which commit production is running, run this from the repository's root:
REPO=devstride/devstride bash .github/scripts/resolve-live-production-sha.sh
It prints the full commit id. It trusts only records made by Seed's own account whose newest status is a success, so a record anyone else wrote cannot fool it. It exits with status 1 when it finds no deployment Seed proved successful, and 2 when GitHub's API failed or was rate-limited. In both cases the answer is "unknown", never "not live".
To check that your change is part of what production runs:
git fetch origin master
git merge-base --is-ancestor <your commit> <the commit it printed>
Exit status 0 means production's commit contains yours.
To see the latest deploys of a stage, newest first:
gh api --paginate 'repos/devstride/devstride/deployments?environment=prod&per_page=100' \
--jq '.[] | select(.creator.login=="seed-deploy[bot]") | [.sha[0:9], .created_at] | @tsv' | head -5
Use environment=dev for the dev stage. Each line is a commit Seed started deploying and when it started. A record on its own does not prove the deploy finished; for production, the script above checks that.
The post-deploy check#
After the owner confirms the deploy, /devstride:release runs the repository's post-deploy check, the ds-post-deploy-release-check skill (named in .claude/ds-config.json as release.postDeployCheckSkill). It runs in two parts, both after the release has handed the clearance back. The check, the first item still owed, does the first two things below and records its verdict as the release/post-deploy commit status on the production merge commit; the next release cannot merge into master until that status is success. The close-out, after the documentation, does the third:
-
It checks production's health, without changing anything, through the
ds-post-deploy-healthskill:- it confirms from Seed's deployment record that production is running the merge commit, waiting up to 25 minutes for a deploy that is still rolling out;
- it waits until at least 15 minutes after the rollout finished, so alarms have had time to fire;
- it looks for any alarm that went off after the deploy started, even one that has since recovered; any dead-letter queue (where messages land after processing fails) that grew compared with just before the deploy; API server errors above the level that trips their alarm; problems on the inbound email path; and any web-app file the deploy meant to upload that is missing from the site's storage bucket or whose contents differ from the build.
Alarms too slow to fire inside that window are listed as not covered, never counted as passed. Problems that were already there before the deploy are listed separately, so they are seen but do not fail the check.
-
It publishes the golden source (the canonical copy of the demo dataset that training sandboxes and stage refreshes clone from) for the release that is now live, and reads it back to prove it is current.
-
It posts the customer replies owed for the items that shipped, and removes the local resources the release created, such as its test containers and its checkout.
Its first line is exactly one of POST-DEPLOY HEALTH: PASS, POST-DEPLOY HEALTH: FAIL or POST-DEPLOY HEALTH: NOT RUN, followed by the evidence, each line naming the command that produced it. PASS turns the release/post-deploy status green, which lets the next release merge. A FAIL or NOT RUN sends one notification naming the machine, session, release, cause and the command to run, then waits; it does not retry in a loop. FAIL stops it for the owner's rollback decision; a failure only in publishing the golden source is repaired and retried instead, and never calls for rolling the application back. NOT RUN means the check could not be done, for example because a sign-in was missing or a service could not be reached, and the owner is asked whether to proceed. Missing credentials are never a PASS.
You can also run the health check by hand after any production deploy: ask Claude Code to run the ds-post-deploy-health skill for the merge commit. It needs a valid AWS sign-in to the production account and a signed-in gh; Credentials and access covers both.
An alarm that fires soon after a deploy is not proof the deploy caused it. Before blaming the release, look at when the alarm's underlying metric first went over its threshold; it may have started before the deploy.
A deliberate redeploy: ds seed deploy#
Normal releases never need a deploy command, because merging is what deploys. For a deliberate redeploy of a chosen commit, ds seed deploy asks Seed to deploy it to a stage:
ds seed deploy --stage <stage> --commit <commit id>
ds seed deploy --stage <stage> --commit <commit id> --force
--force deploys even when Seed finds no changes. The command sends the same request as Seed's own command-line tool, for DevStride's Seed organization and app (--org and --app default to devstride). It needs no AWS sign-in. It uses the team's shared Seed token, SEED_TOKEN, from your machine's agent credentials file (~/.config/devstride/agent.env, written by ds secrets pull), and never prints it.
This token can deploy production
The Seed token is shared and has full access: the owner's decision of 2026-10-05, until narrower keys come later.
ds seed deploydoes not guard any stage.--stage prodstarts deploying that commit to production straight away, without any of the review, CI or owner approval a release goes through. Never run it againstprodwithout the owner's explicit yes for that specific deploy.
If the token has not been added yet, the command refuses and explains how to add it: the owner makes a token in Seed's organization settings and stores it with pbpaste | ds secrets set agent SEED_TOKEN, and each machine then runs ds secrets pull. Credentials and access has the full map of keys.
Hotfixes#
A hotfix is an urgent fix that must reach production without the unreleased work on develop. Run /devstride:branch-hotfix I#####-<short-slug> on a clean tree: it reminds you to stop any running dev server, cuts <you>/hotfix/<YY-MM-DD>/I#####-<short-slug> from a freshly pulled master, pushes it, and resets this checkout's local database so it matches production's older code. Build the fix, then open its pull request into master with /devstride:pr. It gets the draft-first treatment, with Claude and Codex reviewing, then CI, including the backend test suite, because this code has not been tested before. Open it only against master, never against develop as well: a branch open against both can hide a failing check. A hotfix never needs the release clearance: the merge guard and the release-tower check let it through even while a release holds it. /devstride:pr stops when the pull request is reviewed and green; it does not merge it. Merging into master deploys production, so that merge is the owner's call. If a release is open when the hotfix lands, the release merges it into its own branch and reviews it again. Like everything on master, the hotfix comes back to develop through the master-into-develop sync at the end of each release.
When something goes wrong#
merge-pathis red. Runds merge-path check --head <branch> --base developfor the reason. A one-off belongs on the train, and only an infrastructure one-off or an old-style Epic branch should carrymerge-path-override.local-ciis missing, failed, or stuck at pending. Re-runds verify full --poston a clean tree at the pull request's head; a run whose head or files changed part-way posts nothing, so its pending mark stays until a later run replaces it. It needs this checkout's test containers, and only one runs per machine at a time. The full log is.ds/verify-full.log.- The merge guard says "without release clearance". Another release may be in flight: run
ds tower status. If one is, wait for it; its work and yours ship together in the next release. If none is, you are doing a release step by hand: start the release with/devstride:release, or take the clearance withds tower claimfirst. release-toweris red on a release pull request. Another release pull request is ahead of it ("… is on final; this release waits"). It turns green by itself when that one merges or closes. If it stays red after that, rungh workflow run release-tower.yamlto re-check every open release pull request.release-toweris red on any other pull request intomaster. Only a release or hotfix branch belongs there. Retarget it withgh pr edit <number> --base develop.- A release will not merge: the previous release's post-deploy check is not green. Its
release/post-deploystatus is pending or failed. Pending usually means the session that ran that release stopped after handing the clearance back: run/devstride:release post-deploy onlyto finish the check. Failed is the owner's rollback decision. ds tower statussays STALE. The release holding the clearance stopped checking in, usually because its session ended. The next/devstride:releasehandles it: it takes over a release that never opened its pull request, and asks the owner before adopting one whose pull request is open.- A fix on a release branch is refused. It touches deploy configuration or migrations. Merge it into
developby a normal pull request, abandon the release branch and re-cut. - The post-deploy check says FAIL. The owner decides whether to roll back. To triage an alarm without changing anything, paste the alert to the
ds-alarmskill;ds-incident-responseis the full on-call protocol. - The post-deploy check says NOT RUN. Usually a sign-in: the message names the command to run, either an AWS sign-in that reaches the production account (
aws sso login --profile <profile>; see Your AWS sign-in has lapsed) orgh auth login. Run it, then run the check again. A deploy still rolling out after 25 minutes is also NOT RUN: check again once it finishes.
Anything else: Troubleshooting.
Next: Troubleshooting, for when a step on any page does not go as described.