ds work
On this page
Defined in cli/commands/work.ts. Starts and lands one item on the branch it belongs to, inside a pool checkout you lease. It is the delivery loop's routing rule for agents and people who do not run the DevStride plugin — Codex, or work by hand — so nobody has to remember where an item lands. It skips the wrapper's AWS gate and stage bind: it reads DevStride with the agent's own key (from ~/.config/devstride/agent.env) and otherwise touches only git.
Where an item lands. The item's nearest Epic's integration branch (<user>/<YY-MM-DD>/epic-<I#####>-<slug>, created off develop when none exists); with no Epic above it, the release train, train/release, which ships with the next release. Nothing lands on develop or master directly. The plugin's routing helper (routing.py) decides the same thing, and a test runs the plugin's canonical examples through ds work, so the two cannot drift apart. See Where work lands for the why.
Every subcommand that changes git needs a checkout you hold (ds pool checkout) and a clean tree; pass --session <name> or set DEVSTRIDE_SESSION.
ds work start#
ds work start <I#####> [--slug <kebab>] [--infra | --target <branch>] [--one-off] [--session <name>] [--dry-run]
Cuts the item's feature branch, <user>/<YY-MM-DD>/<I#####>-<slug>, from a fresh copy of its target and records the target on the branch (branch.<name>.dsTarget in local git config) for ds work land. It then moves the item to In Progress.
| Flag | Description |
|---|---|
<I#####> |
Required. The item number. A container item is refused |
--slug <kebab> |
The branch name after the item number. Default: the item's title |
--infra |
A one-off that changes deploy configuration or migrations (stacks/, sst.config.ts, migrations): cut from develop instead of the train, to ship by its own pull request with the merge-path-override label. ds work land never lands it. Why: the train reaches production at the next release with little time between, and such a change deserves its own CI and an earlier deploy to the dev stage. Refused for Epic work, whose release pull request carries its infrastructure with the rest |
--one-off |
An item filed under an Epic that is still a one-off: send it to the train, never to that Epic's branch — the same rule /devstride:create-story follows |
--target <branch> |
Land on this branch instead of the one the rule picks. Needed when an Epic's integration branch predates the epic- marker, which start stops and asks about rather than cut a second one |
--dry-run |
Say what would happen; change nothing |
If the configured release train (train/release) is missing on GitHub, start decides as the plugin does: exactly one other train/* branch is still the live train and the work rides it, several stop and ask which is live, and none means the train is created.
ds work land#
ds work land [--session <name>] [--no-verify] [--dry-run]
Run on the feature branch start created. It merges the target's newer work into the branch, runs the local gate on that combined tree — ds verify land against the target — then merges the branch --no-ff onto the target and pushes. It never pushes to develop, master or another protected branch, never forces, and leaves the feature branch alone. After the push it moves the item to Review and adds one comment naming the branch it landed on, the merge commit, and when it ships. A one-off on the train is not Done when it lands: it is Done when the release carries the train into develop.
Status moves. start and land move the item exactly as the DevStride plugin's build loop does, because both ask the plugin's own status rule (item-status.py, plugin 3.32.0 or newer) which status to set. ds work only reads the item, applies the answer and reads it back. A status move that fails never stops the start or the landing: it says so once and leaves the item as it was.
Before anything merges, a train landing asks two of the DevStride plugin's own rules, so it holds back exactly the work the plugin's build loop would:
- Release holds (
release-holds.py, plugin 3.36.0 or newer). ARelease hold:line in the description of the item or any work item above it keeps the landing off the train until the hold lifts (dates are read in US Central time). A hold that cannot be read counts as a hold. - The review gate (
review-gate.py). A one-off within the small-fix limit (at most 5 files and 500 changed lines, nothing on the high-risk list) lands as before. A larger one lands only when a settled full Claude + Codex review is recorded at exactly the branch's own commit. Otherwiselandstops and names the review to run (/devstride:review local-full origin/train/release). Any new commit, including one that resolves a conflict with the train, needs the review again. The merge commit records the size, or the review's cycles and findings.
Without a plugin that carries these scripts, every train landing stops and says to run /devstride:update.
- An infrastructure change on a train branch is refused before anything merges, with the exact commands to move the branch onto
developand open its own pull request. Why: the check runs on the branch's own changes, so the train's other one-offs never come along with it. - A branch targeting
develop(one started with--infra) is refused: open its pull request with/devstride:pr, then add themerge-path-overridelabel. --no-verifyskips the local gate, with a warning — refused for the train, because nothing else checks that code before the train's pull request.
ds work train status / ds work train rotate#
ds work train status
ds work train rotate [--create]
status lists the one-offs on the train that have not reached develop yet (read-only). rotate fast-forwards the train to develop once a release has carried everything on it, and does nothing while it still carries unreleased work; --create creates the train at develop when it does not exist yet. The release normally does this for you.
ds work dependabot-batch#
ds work dependabot-batch [--session <name>]
Folds every open Dependabot pull request into develop onto one new branch, dependabot/batch-<YY-MM-DD> (-2, -3… when that name is taken), and pushes it. Run it in a checkout you lease, on a clean tree. When two updates both rewrote the lockfile, it keeps either side and regenerates the lockfile once at the end; an update that conflicts anywhere else is left out and named, to batch next time or apply by hand. The batch's own commits skip the commit hooks, which would otherwise rewrite the lockfile half-way and leave the tree dirty.
Then open the branch's pull request into develop with /devstride:pr: the local-ci check runs the full local mirror on it once. Dependabot closes each original pull request itself once develop carries its update.
Why. Every pull request into develop needs a green local-ci, which is a full run of about half an hour. Checking a week of Dependabot updates one by one would cost that many runs; batched, it costs one.