Framework Architecture

Both runtimes must call one shared implementation of the business actions and report into a single result store. Only the entry point differs. Copy the behaviour instead of sharing it and the two halves drift apart silently.

A leaked detail in an action's signature — a raw response, an element identifier — puts the transport into every caller. Replacing the adapter then changes the signature and every case using it, so the boundary protected nothing.

Failures that say the change is unsafe block the stage. Failures already triaged and accepted, and checks advisory by design, are reported without blocking. Put the split in a written classification the suite applies, not in a per-run argument.

History is joined on identity. If a case is identified by its display name or its position in a file, rewording a sentence or inserting a case above it destroys the past outcomes and creates a brand-new case carrying none.

A pass that needed a second attempt is evidence that a case is unstable. Merging it into a plain pass destroys the only proof that instability exists, so the suite keeps reporting green while its reliability quietly decays.

Treat worker count as a variable you control: reproduce at two workers, shrink to the smallest failing pair, then run the case beside a copy of itself. Then hunt the writer, not the reader that reported red.

A measured burndown that will not finish before the reason for moving expires, a blocking constraint structural in the old design rather than incidental, and a plan that keeps the cases' behaviour. Dislike is not evidence.

It is a coupling-versus-duplication call. Share business actions only when both teams mean the same thing by a flow and need changes to land together. Otherwise give each team its own actions over a shared adapter layer.

Choose between two models: hand each worker its own slice of a scope the product already models, or run a wide pool of self-contained cases beside a small exclusive lane holding named locks. What the product scopes decides which.

First attribute the thirty-five minutes between fixed invocation cost and per-case cost. Then split one entry point into several with declared budgets and blocking rules, and make each enforce its own deadline rather than being killed.

Choose by who reads it. An interchange shape everything already parses buys integration you never maintain and costs expressiveness; a bespoke model expresses your statuses and attempt history exactly and costs you every reader you must now write and keep writing.

A failure means the product is wrong; a skip means the check did not apply here. Marking a case that needs an absent feature as skipped keeps the failure list meaningful, while a red result trains everyone to ignore red.

Mechanical rewrites are safe when the change is purely syntactic and every call site means the same thing. They turn unsafe the moment a site needs judgement: a value to choose, or an intent the old code expressed badly.

Reproducibility. Steps that exist only in the pipeline definition cannot be run locally, so every change to them costs a push-and-wait cycle, and what a developer runs slowly diverges from what the gate runs.

Attach evidence to the smallest node that owns it — the failing case, and where the model has them, the specific attempt and step. Evidence parked at run level makes a reader search for which case it belongs to.

Inheritance earns its place when the work is invariant across every descendant, takes no value the case chooses, and no case could ever want it off — failure capture and result reporting qualify. Once an opt-out is thinkable, compose instead.

Nothing pins the value. Reads spread across a run see different answers if a layer changes underneath them, no moment exists at which the full input set could be recorded, and parallel cases can act on different values.

A handle rather than a bare identifier: the record asked for, the identities of everything created alongside it, and a tag naming the case and run that asked. That tag is what makes ownership answerable after the run has ended.

Run duration climbs within a single run, host resource use rises and never falls back between cases, orphan processes survive the run, and late cases fail with resource errors that name the machine rather than the feature.

Publishing an extension point freezes what the framework passes in, what it accepts back, when it calls and how often, and what a thrown error does. Widening any of those forces every dependant to change at once.

Split by cost. Evidence that is cheap to produce and expensive only to keep — the step log, durations, identifiers — is produced always into a bounded buffer and written only on failure. Evidence expensive to produce is gated behind a failure.

Recognise it by its symptoms: a name that names no subject, imports from every layer, and nothing that can be extracted. Break it up by freezing it and moving out one cohesive group at a time.

Running with one worker changes no code: it removes the only thing exercising the coupling, not the coupling itself. The constraint stays unnamed, its cost grows with every case, and it may hide interference real users will meet.

A per-case cap bounds one case's attempts and nothing bounds how many cases retry. A run-level budget caps total re-execution across the suite, so a suite-wide breakage reports red quickly instead of paying the full cap on every case.

Scoping removes the mix-up, not the hidden dependency. A helper that reaches for an ambient current-case value has an input its signature does not declare, cannot be reasoned about locally, and misbehaves wherever no case is in scope.