release.yaml, and every rule it is checked against

The document does not match the schema

Structural: a wrong type, an unknown key, a value outside an enum. Reported before any semantic rule runs, because running semantics over a malformed document produces cascading nonsense.

needs names a job that does not exist

Usually a rename that missed one reference. The graph is built from these names, so an unresolvable one is a job that can never start.

The job graph has a cycle

Two or more jobs waiting on each other. The engine would never schedule any of them, and it would look like a queue problem rather than a config one.

A job depends on itself

The degenerate cycle, called out separately because the fix is obvious once named.

Two steps in one job share an id

Step ids are how one step references another's output. Two steps with one id makes that reference ambiguous.

Retired: an expression referenced an unknown step id

Never emitted. It described an error inside a `${{ }}` expression, and Conductor does not evaluate expressions — E017 refuses them outright. The code is kept so it is never reused for something else.

Retired: an expression referenced a job not in needs

Never emitted, for the same reason as E014: there are no expressions for it to be about. Kept reserved rather than reused.

A field the schema accepts and Conductor does not implement

`if:`, `outputs:`, `strategy.fail_fast: true` and `strategy.max_parallel` are part of the file format and nothing acts on them. Accepting them silently meant a job with `if: false` ran anyway; refusing them means nobody builds on a behaviour that is not there.

A `${{ }}` expression, which nothing evaluates

Conductor has no expression language, deliberately: a job's credential set must be computable by reading the file. An expression would be passed along as literal text. Matrix values arrive as CONDUCTOR_MATRIX_<KEY> environment variables, the run's ref and SHA as CONDUCTOR_GIT_REF and CONDUCTOR_GIT_SHA, and a concurrency group is already scoped to its ref.

uses names a step that is not in the registry

The registry is the whole step library, so this is a typo or a version of Conductor older than the step. The diagnostic suggests the nearest name.

The step exists; that major version does not

Steps are versioned per major. Pinning one that was never published fails here rather than at dispatch.

`with` violates the step's input schema

Each step declares a JSON Schema for its inputs, and it is checked here rather than by the step failing on the machine.

A required input is absent

Separated from the schema error above because “you forgot one” and “this value is wrong” are different problems with different fixes.

A distribution step is in a pull-request workflow

A pull request must not be able to ship anything. This is an error rather than a warning because the failure mode is a build reaching testers from an unreviewed branch.

core/shell is in a job that also distributes

A shell step in a job holding store credentials is the shape of an incident: arbitrary commands beside standing, high-privilege material. Split the shell work into a job the distribution job depends on.

A step needing a sensitive credential is on the untrusted pool

The untrusted pool is where a fork's pull request runs, and it never receives standing credentials. A clone token is not sensitive and does not trip this — a fork may check out the code it is testing.

A fastlane lane needing credentials is reachable from a fork

An adopted Fastfile is arbitrary Ruby holding injected credentials. Running it credential-free on a fork fails in a way that looks like Conductor broke it, so it is refused instead.

A job resolves credentials and does not say which app it targets

Which credential satisfies a purpose is resolved per app. Without `app: ios` or `app: android` there is nothing to resolve against, and the build would have to guess.

One job mixes runner steps with control-plane ones

A job runs entirely on one side. Mixing them would mean a workspace that exists for half the steps in it.

A job selects a variant that is not declared

`variant:` names one of apps.<app>.variants — another build of the app that is a separate app at the stores, with its own bundle id or package. It needs an `app:` to be a variant of, and the variant has to be declared there; otherwise there is no identifier to sign or ship it under, and the run would fail minutes in instead of here.

A pull-request workflow asks for a signed build

Pull request builds are never signed or archived — Conductor forces both off for every pull_request run, so the build needs no credential and a fork's pull request can run at all. An explicit `signed: true` is a line claiming something that will not happen.

A pull-request workflow step needs signing material

A pull request's run never receives a credential that signs — not by forcing a build unsigned, which covers ios/build, android/build and flutter/build, but at the credential boundary, so ios/sign and a fastlane lane listing ios_signing or android_signing cannot reach it either. Sign in a push or manual workflow.

ios/build or ios/test has no Xcode scheme

xcodebuild's default scheme depends on which schemes are shared and how they sort, so the step refuses to guess. Name one on the step, or once under apps.ios.scheme; a shared scheme is a file in xcshareddata/xcschemes, which is also where Conductor's detection looks.

A store-account identifier appears in the config

No Apple Team ID and no Play developer id may appear in release.yaml. That rule is the entire reason a project can be moved to a different store account as a configuration change rather than a rewrite.

A distribution step names no target

`target` is how a step says where a build goes; the store account, credential and app behind the name are resolved at run time. The step library lists it as optional for compatibility, but no distribution can run without one, so leaving it out is refused here rather than at the last step of a pipeline.

The step is declared but cannot run on this version of Conductor

A control-plane step whose executor is not implemented yet. It would validate, schedule and then fail at run time, so it is refused while the file is still being written.

The step is in the registry but this version of Conductor does not run it

A step that was declared and turned out not to work. The registry only ever grows, so it stays listed; it is refused here, with the reason and what to do instead, rather than failing a run.

A fastlane step is used while mode is native

Native mode means typed steps only. Set `mode: hybrid` if you want both, which is a deliberate choice rather than an accident.