On this page

Defined in cli/commands/verify.ts. The local mirror of cloud CI, so the deep checks run on the team's own machines and paid cloud CI runs only at release. It skips the wrapper's AWS gate and stage bind and needs no login. It does need this checkout's test containers.

All three subcommands share a machine-wide lock, ~/.cache/devstride/verify.lock: one run per machine at a time, with one exception: two light landing checks (a ds verify land that runs neither the whole suite nor a pre-ship check) may share it, each with half the test workers. A run that has to wait says whose run it is waiting on; the lock of a run that died is reclaimed. Each step prints one line, a failing step prints the end of its output, and the first failure stops the rest. The whole log and a receipt are written to .ds/verify-<land|full>.log and .ds/verify-<land|full>.json.

--base <ref> sets what the change is measured against. By default it is the target ds work start recorded for the branch, else whichever of develop, the release train and the epic integration branches is the closest ancestor. --dry-run prints the steps and stops.

ds verify land#

ds verify land [--base <ref>] [--dry-run]

The check every Story and one-off passes before it merges onto its Epic's branch or the train. ds work land runs it, and so does the plugin's per-story gate. For the files the change touches, it:

  1. installs dependencies from the frozen lockfile, as CI does, so a dependency bump is tested with its new versions;
  2. runs every type-check (the frontend's with 8 GB of memory, which it needs on a large change);
  3. runs ds verify sast, the cloud's Semgrep security scan, when the change has a target branch;
  4. runs eslint on the changed frontend files — errors fail the run, and formatting is fixed in place, so commit what it changes;
  5. runs every backend and frontend test whose imports reach a changed file. A file no import can reach (a hook script, a config file, a workflow) finds the backend specs that name it; It also runs that side's whole-tree checks, the specs that read the source instead of importing it. One of them is the vocabulary fence: a change that adds an old lane or folder name (the words the product replaced with status and workstream) fails, unless it is one of the few names kept on purpose. Files that still hold old names are listed in docs/rename-program/vocabulary-fence-registry.json with their counts, which may only go down; after removing some, lower them with node .github/scripts/vocabulary-fence.mjs --tighten;
  6. runs the MCP server's checks when packages/mcp changed;
  7. runs the pre-ship checks the changed paths trigger (preShipChecks in .claude/ds-config.json).

A broad change — the test harness or the lockfile, say — runs the whole non-golden backend suite instead, and says why. A change landing on develop, the release train or an Epic's branch never widens this way: the cloud runs the whole backend suite on the pull request into develop, so the landing check runs only the related tests, however many there are.

A green result is reused, never a red one. Run again on exactly the same commit, the same target commit and the same scan rules on develop, with a clean tree then and now, a check whose every step passed says so and stops instead of running everything a second time. Any difference (an edit, a moved target, new scan rules, a step that failed or did not run) runs the whole check.

Why. Before it, a logic fix with no test edit landed on the type-check alone, and its breakage was first found at the release.

ds verify sast#

ds verify sast --base <branch>

The cloud's sast check (a Semgrep security scan) on this machine, as a pull request from HEAD into <branch> would run it. It runs the scan workflow's own scripts, read from .github/workflows/sast.yaml, so it uses the same pinned Semgrep image, the rules on develop and the same rule for failing: a finding the base branch does not already have. It scans the committed HEAD, not uncommitted edits, and needs Docker. If it cannot fetch develop and the target, it fails rather than scan stale rules. ds verify land runs it for you.

Why. A finding used to surface only on the release train's pull request, an hour or more after the work landed, and held the whole release while it was fixed.

ds verify full#

ds verify full [--post] [--adopt-release] [--base <ref>] [--dry-run]

Everything cloud CI runs on a release pull request, on this machine: a frozen-lockfile install, every type-check, eslint over the whole frontend (errors only), the MCP and frontend tests, the UI build and the portal bundle budget, a readiness probe on this checkout's test Postgres, the whole non-golden backend suite, and the pre-ship checks the change against develop triggers. It takes about half an hour. A test compares this list with the cloud workflows and fails when a cloud check has no local counterpart.

Flag Description
--post Record the result as the local-ci commit status on HEAD. It refuses to start on a dirty tree, posts pending while it runs, and posts success only when every step passed on that exact commit. If HEAD or the tree moves during the run, nothing is posted
--adopt-release With --post: when HEAD's tree is exactly the tree a merged release pull request into master already tested green in the cloud, post success citing that run instead of running everything again. This is how a master-to-develop sync gets its local-ci in seconds
--base <ref> What the change is measured against; it selects the path-triggered pre-ship checks
--dry-run Print the steps and stop

Every pull request into develop must carry a green local-ci before it can merge. The delivery loop runs ds verify full --post --adopt-release as its local-ci pre-ship check before it marks the pull request ready; see Deployment. Posting the status needs a GitHub token that can write commit statuses on the repository; the agent's token is used when this machine holds it.


ds verify exec#

ds verify exec -- '<command>'

Runs one check that gates a merge into a shared branch (the release train, an Epic's release into develop, or the release into master) under the same machine-wide lock, so two sessions' gating checks queue instead of overlapping. Every preShipChecks entry in .claude/ds-config.json runs through it — the golden suites, infrastructure synthesis and golden release readiness — except the release's AWS sign-in check, which takes seconds and starts no containers. It first installs dependencies from the frozen lockfile, as land and full do, because pnpm only warns when a checkout's packages are behind its lockfile, so a check would otherwise run against stale packages. A failed install stops the check. Run inside an enclosing ds verify, it runs at once: the parent already holds the lock and has installed.

Waiting runs take their turn in the order they arrived, with one exception: a run from the session that holds the release clearance waits ahead of every other waiting run, so a release that holds up every machine is not stuck behind routine story checks. It never interrupts the run in progress. A check the same session already has running or waiting in the same checkout is refused instead of queued twice: it names the earlier run and exits 3, which means nothing ran, not a pass.

Ordinary test runs in your own checkout don't need it.

ds verify golden-receipt#

ds verify golden-receipt read --tree <tree>
ds verify golden-receipt run --tree <tree> -- <command>

The full golden dataset suite takes about 28 minutes, and the same code is often needed on several machines: a release branch cut from a train snapshot already tested, a check on another machine. So a pass is recorded once, for every machine, against the exact version of the code (its git tree, git rev-parse HEAD^{tree}), as a claim of kind golden-receipt in DevStride. read exits 0 with one line naming the earlier run when a pass is recorded for that tree, and 1 otherwise. run claims the tree, runs the command while checking in, and records pass or fail, exiting with the command's code. A machine that arrives while another is running the same tree waits for that run (at most 90 minutes) and reuses its pass instead of starting a second one. A failure, uncommitted files or a different tree run the suite again; with no agent key or DevStride unreachable, the command simply runs with no receipt. The golden pre-ship checks call it for you. It reads DevStride with the agent credentials file, and needs no AWS login.

Powered by DevStride