@cratis/pi 7.128.0 → 7.129.0

package/package/corpus/skills/cratis-screenplay-render-and-gap-fill/SKILL.md

@@ -42,10 +42,10 @@ mode; query-performer gaps are a separate contract, not completed behavior. Prot
 support is not generated-app protection.
 Preserve contracts; reference success is not target realization.
 
-File/inline command handlers permanently require constrained attachments: gap-fill
-in code, not by waiting for ESM admission. Requires Screenplay 4.210.0
-(`screenplay --version`) for PLAY0800 and required typed `arguments.subject`;
-older binders use PLAY0268. Read [renderability gate](references/renderability-gate.md)
+A file/inline command handler binds beside unconditional `produces` with a resolved
+body (v23 result contract, Screenplay 4.250.0); without them it refuses PLAY0800 with a
+required typed `arguments.subject`. 4.210.0 to 4.249.x refuse every attached handler
+with PLAY0800; older binders use PLAY0268. Read [renderability gate](references/renderability-gate.md)
 when classifying a handler or other binding refusal; never parse message text.
 
 Inline bodies (`csharp`, `typescript`, `react`, `html`, `sql`, `java`) are opaque and reach the target

package/package/corpus/skills/cratis-screenplay-render-and-gap-fill/references/renderability-gate.md

@@ -10,10 +10,11 @@ probe reports and choosing what to do. Do not copy the code table here.
 1. The CLI compiles and binds the **whole** model with its **bundled** Screenplay (the ESM level it renders is bounded by the bundle; older bundles bound less). Binding is never scoped:
    any binding error blocks even a `--scope` render. Binding errors are `PLAY0268` (outside the admitted vertical), `PLAY0269`
    (deferred), `PLAY0270` (report-only information), `PLAY0271` (legacy semantics) and `PLAY0273`
-   (a specification shape). File/inline command handlers instead report PLAY0800
-   (`CommandHandlerRequiresAttachment`), a permanent constrained-attachment requirement.
-   Requires Screenplay 4.210.0 (`screenplay --version`); older bundled binders use
-   PLAY0268 for these handlers. Hosts read the required typed `arguments.subject`
+   (a specification shape). A file/inline command handler without unconditional `produces`
+   or a resolved body instead reports PLAY0800 (`CommandHandlerRequiresAttachment`); beside
+   unconditional `produces` with a resolved body it binds as the v23 result contract.
+   Requires Screenplay 4.250.0 (`screenplay --version`); 4.210.0 to 4.249.x refuse every
+   attached handler with PLAY0800 and older bundled binders use PLAY0268 for these handlers. Hosts read the required typed `arguments.subject`
    to identify the command, never the message.
 2. Execution planning builds the plan and can emit `PLAN-*` diagnostics before Stage runs.
 3. Stage plans the target and admits or rejects each member: `STAGE-ESM-0xx`; profile and path
@@ -36,7 +37,7 @@ ESM). Only the probe answers renderability. `PLAY0270` entries are information,
 | --- | --- | --- | --- |
 | **Model fix (in mode)** | the model is in, or the user chose, renderable mode and breaks its own subset in a way that has a renderable equivalent with the same meaning | a `produces` whose `for` is not the command identifier; two projections for one read model (`-007`); a policy Stage cannot express portably (`-015`; role-only and opaque pure policies render) | edit request to the modeler session with address, change and rationale |
 | **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to` and a list-query `by` block remain PLAY0268; an unsupported query performer (observable, a non-C# body, or a missing, changed or non-compiling body) becomes an explicit implementation gap, while a verified C# body renders ([performer bodies](../../cratis-screenplay-read-surface/SKILL.md#performer-bodies-are-rendered)); a read model with several key parts or a projection keyed by parts (v27) refuses `STAGE-ESM-048` (always for a DateTime or decimal key part; the decimal refusal lifts with Stage#847 once Chronicle#5427 lands) and a single-instance query by parts `STAGE-ESM-047` (Chronicle#4265); Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected reads the renderer cannot preserve, or any protected read in an older CLI bundle (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-043; v22 admission Requires Stage 4.139.0, older Stage reports -016) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
-| **Implementation attachment** | a permanent limitation, not future ESM admission | file/inline command handlers (PLAY0800; typed `subject` names the command) | keep the model contract and gap-fill the slice in code with a constrained implementation attachment; do not wait for a new ESM version |
+| **Implementation attachment** | the handler shape, not future ESM admission | file/inline command handlers without unconditional `produces` or a resolved body (PLAY0800; typed `subject` names the command) | declare unconditional `produces` beside a resolved body, split variable outcomes into separate commands, or keep the model contract and gap-fill the slice in code |
 | **Tool skew** | the bundled compiler disagrees with documented semantics | the false `PLAY0285` on reaction cascades from an older bundle; codes the standalone compiler does not raise | record in the session state and the fallback record; never "fix" a correct model |
 | **Environment** | not the model | restore failures, missing SDK, a destination that is not writable | fix the environment or report blocked |
 

package/package/corpus/skills/cratis-screenplay-scenario-coverage/SKILL.md

@@ -175,8 +175,8 @@ Use a separate `when added` append when initial observations should produce a fa
 Read captures-and-reactions `references/record-capture-specifications.md` for the
 prerequisite and runnable cases. Include first, changed and unchanged rows in the matrix.
 
-## Version skew: reaction cascades and false PLAY0285
-Under ESM v6 a command spec's `then` lists the events reactions cascade from it; an older `cratis` bundle reports a **false PLAY0285** for it. Never delete the reaction. Read [references/version-skew.md](references/version-skew.md) when a spec with cascade events reports PLAY0285 or the bundled compiler is older than the standalone tool.
+## Reaction chains: one slice per specification
+A specification runs only its own slice. Prove a chain across slices link by link: the command's spec states its own events, the Automation's `when append` spec states what it appends, and `then invokes <Command>` (ESM v34) states a command it invokes in another slice. Another slice's event in a spec is PLAY0285. Never delete the reaction. Read [references/version-skew.md](references/version-skew.md) when a spec reports PLAY0285 or the bundled compiler is older than the standalone tool.
 
 ## Gate
 A scope is spec-complete only when: the matrix has no `open`, `question` or `gap` cell (or the

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/invoicing-dues-design.md

@@ -203,9 +203,6 @@ module Invoicing
         then PaymentReversed
           for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
           amount = 130
-        then RefundRequested
-          for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
-          amount = 130
 
       specification RejectingAReversalWithoutAReceivedPayment
         given caller

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/invoicing-dues-example.md

@@ -227,9 +227,6 @@ module Invoicing
           for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
           outcome = "declined"
           reason  = "Card declined"
-        then PaymentDeclined
-          for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
-          reason = "Card declined"
 
     slice Automation RecordPaymentOutcome
       reaction ReceivedTranslator
@@ -247,6 +244,14 @@ module Invoicing
       event PaymentReceived
       event PaymentDeclined
         reason String
+      specification RecordingADeclinedPayment
+        when append PaymentGatewayResultReceived
+          for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
+          outcome = "declined"
+          reason  = "Card declined"
+        then PaymentDeclined
+          for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
+          reason = "Card declined"
 
     slice StateView OpenInvoices
       description "Todo list: membership means 'still to collect'; there is no status flag."

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/scenario-examples.md

@@ -104,9 +104,9 @@ design-mode rejection spec and `recorded` in the matrix. See `RejectingSettlemen
 in `invoicing-dues-design.md`; it is never prose and never a spec that pretends to enforce it.
 
 ## 3. External failure: the capture, then the retry
-Two separate obligations. First, the **capture specification**: concrete external input in, our
-facts out. The provider's refusal is a fact (never a `then error`), kept in the provider's
-vocabulary; a separate Automation records the local outcome. The capture uses
+Two separate obligations. First, the **capture specification**: concrete external input in, the
+provider's fact out. The provider's refusal is a fact (never a `then error`), kept in the provider's
+vocabulary; a separate Automation records the local outcome and states it in its own specification. The capture uses
 `when added` for first sight and a separate `when outcome` for updates. An update
 spec needs `given capture` with the same key's earlier record; the first record's
 fields are not modifications (root, child or nested). See captures-and-reactions
@@ -121,6 +121,15 @@ specification TranslatingADeclinedCardResult
     for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
     outcome = "declined"
     reason  = "Card declined"
+```
+The Automation that records the local outcome proves its own link in its own slice
+(a specification runs only its slice, Screenplay decision 0115):
+```screenplay excerpt parent=references/invoicing-dues-example.md#1
+specification RecordingADeclinedPayment
+  when append PaymentGatewayResultReceived
+    for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
+    outcome = "declined"
+    reason  = "Card declined"
   then PaymentDeclined
     for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
     reason = "Card declined"
@@ -153,9 +162,11 @@ model; it tests the projection only, never the translation.
 
 ## 4. Compensation
 A reversal needs a paid history, the reversal action and the exact consequence. The command spec
-lists the declared consequence (`RefundRequested`); the reaction is also specified on its own.
-`RefundRequested` is a recorded request, not proof that money moved, and there is no
-`then <Command>` form. What the target must do to deliver the refund is a requirement, not a spec.
+states the command's own fact (`PaymentReversed`); the `RequestRefunds` Automation states
+`RefundRequested` in its own specification, because a specification runs only its own slice
+(Screenplay decision 0115). `RefundRequested` is a recorded request, not proof that money moved.
+An automation that invokes another slice's command states it with `then invokes <Command>`
+(ESM v34). What the target must do to deliver the refund is a requirement, not a spec.
 From `invoicing-dues-design.md` (design mode; the specs do not run):
 ```screenplay excerpt parent=references/invoicing-dues-design.md#1 expect PLAY0516 test=unbound
 specification ReversingAReceivedPayment
@@ -174,9 +185,6 @@ specification ReversingAReceivedPayment
   then PaymentReversed
     for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
     amount = 130
-  then RefundRequested
-    for "9c1f0a52-6a4e-4b1c-9f55-0d2c7b8e1a01"
-    amount = 130
 
 specification RequestingARefundAfterAReversal
   when append PaymentReversed

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/spec-forms-by-mode.md

@@ -29,7 +29,8 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | `when query` -> `then result` / `then no result` | yes | yes | same as `then query`: only the query-only cases below |
 | `given clock` / `when clock`, `when trigger`, record-source `given`/`when capture` | yes | yes (standalone and any cratis whose compiler admits v6; an older bundle does not, see toolchain `references/executable-subset.md`) | no |
 | Event-source capture fixtures | `given <FromEvent>` / `when append <FromEvent>`, not capture records (PLAY0701) | admitted root capture behavior executes; see `public-event-coverage.md` for prerequisites and limits | separate target admission |
-| Command spec listing reaction cascade events | yes (v6 semantics) | false PLAY0285 on an older cratis bundle only; see SKILL.md "Version skew" | no: STAGE-ESM-011; generated CommandScenario does not settle reactions |
+| Command spec listing its own slice's reaction cascade events | yes (v6 semantics) | yes; another slice's event is PLAY0285 (decision 0115); see SKILL.md "Reaction chains" | no: STAGE-ESM-011; generated CommandScenario does not settle reactions |
+| `then invokes <Command>` in an Automation spec | yes | yes, ESM v34 | Stage spec runner compares it; the Cratis renderer refuses models after v33 (STAGE-ESM-016) |
 | `generated <name> = <value>` under `when`, `then returns` (ESM v7) | yes | yes on a compiler that admits v7 (PLAY0268 on an older bundle) | yes on Stage for supported UUID/String strategies and v15 freshness and scalar/named responses; unsupported types/combinations remain -028/-038 |
 | v15 generation strategy fixtures and used-source rejection | yes | strict encoding/size/case/version/variant; Contract for invalid pins, Concurrency for reused source | supported strategies/freshness render; invalid pins refuse -011, unpinned unordered/projected assertions -038; source: command-surface `references/generated-values-and-responses.md` |
 | `then events in any order` | yes | yes | yes |
@@ -44,13 +45,13 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | Date rules using `today`, `$context`, mixed `Date`/`DateTime`, concept or reaction-`where` positions; nested paths | spec them in design | rule does not bind: `recorded` | `recorded` |
 | Bodied rules, code policies | spec them | spec reported **unsupported**, never passed | no |
 | Pending described command handlers (v23) | specify intent | binds; denial/validation execute, body-reaching specs Unsupported ImplementationBody; all-Unsupported is not green | STAGE-IMPL-002 even Stub mode |
-| Attached command handlers | spec them in design | blocked: PLAY0800, no spec runs (V3 blocked); permanent constrained-attachment requirement, gap-fill in code | no |
+| Attached command handlers | spec them in design | beside unconditional `produces` with a resolved body: binds v23, a spec reaching the body is Unsupported (`ImplementationBody`); otherwise PLAY0800, no spec runs | Stage renders a C# body; generated specifications execute verified synchronous C# handlers |
 | `file` constraints | spec them in design | blocked: PLAY0268 at binding, no spec runs (V3 blocked) | no |
 | Query `performer`s | spec them in design | opaque read: PLAY0270 information, left out of the executable model; a spec that reads it is left out, every other spec still runs ([version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does); older compilers report PLAY0268) | no |
 | Atomic reaction mode (v22) | declare for new models | failed batch adds no facts or view changes; earlier batches/commands remain; `then error` alone is insufficient | v22 STAGE-ESM-016; mode in admitted v23–v27 STAGE-ESM-043 |
 | Protected command reads (v25) | declare opt-in for eligible reads | absence Validation; matching intervening facts Conflict; race vectors are not a new spec construct | Cratis C# rendering in a new enough bundle (STAGE-ESM-044 before, or for unpreservable shapes); semantic Host/executor execute admitted reads, non-Error protected requirements STAGE-ESM-045; v25 pair admitted |
 
-Requires Screenplay 4.210.0 (`screenplay --version`) for attached handlers to report PLAY0800; older binders use PLAY0268. Other PLAY0268 families are unchanged.
+Requires Screenplay 4.250.0 (`screenplay --version`) for attached handlers beside `produces` to bind; 4.210.0 to 4.249.x report PLAY0800 for every attached handler and older binders use PLAY0268. Other PLAY0268 families are unchanged.
 
 Requires Screenplay 4.105.0 or later (`screenplay --version`) for list-query specifications, and 4.143.0 or later for collection equality filters (ESM v14).
 

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/version-skew.md

@@ -1,14 +1,25 @@
-# Version skew: reaction cascades and false PLAY0285
-
-How to specify reaction cascades across compiler versions.
-
-Under ESM v6 a command spec's `then` lists the events reactions cascade from it. A compiler
-bundled in an older `cratis` reports a **false PLAY0285** for such
-a spec; the standalone `screenplay` and a `cratis` whose compiler admits v6 accept it.
-Neither checks that a cascade event is *missing*.
-- A compiler that admits v6 (standalone, or a current `cratis`): write the v6-correct spec
-  (own productions plus cascade); validate with `screenplay <folder> --warnaserror --no-color`
-  or `cratis screenplay validate <folder> --warnings-as-errors`.
-- Only an older `cratis` bundle and no standalone tool: keep the command spec to its own productions, specify the reaction in its
-  Automation slice (`when append <Trigger>` -> `then <Produced>`), record the pending cascade
-  expectation in `STATE.md` as known-incomplete. Never delete the reaction.
+# Specifying reaction chains across slices and compiler versions
+
+How to specify a chain of reactions, and what `PLAY0285` means on each compiler.
+
+Requires Screenplay 4.246.0 or later (`screenplay --version`) for single-slice runs and `then invokes`.
+
+A specification runs only the slice that declares it (Screenplay decision 0115, for every model
+and version). A chain across slices is proved link by link:
+- The command's slice: `when <Command>` states the command's own events.
+- The Automation slice: `when append <Trigger>` states what its reaction appends, and
+  `then invokes <Command>` (ESM v34) states a command it invokes in another slice.
+- The invoked command's slice: `when <Command>` states that command's events.
+
+A command spec that states another slice's event is refused with `PLAY0285` (unreachable)
+and fails at run time with "Expected N fact(s), got M". That is a modeling error: move
+the expectation to the slice that produces it. Never delete the reaction.
+
+Older compilers:
+- A compiler older than ESM v6 does not trace reactions and can report `PLAY0285` on a
+  reaction in the specification's own slice. That is tool skew: validate with the
+  standalone `screenplay <folder> --warnaserror --no-color` or a current
+  `cratis screenplay validate <folder> --warnings-as-errors`, and record which tool gave which verdict.
+- A compiler that predates `then invokes` refuses it. With only such a tool, keep the
+  automation's own appended facts in its spec and record the pending hand-over expectation
+  in `STATE.md` as known-incomplete.

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/view-and-story-specs.md

@@ -142,12 +142,13 @@ not prove an entire list is empty: assert the unkeyed list query itself (an unke
 - **Projection lag**: a spec asserts the settled state. If a screen decision depends on the view
   being current (a booking screen that must not offer a taken berth), that is not protection:
   the command needs its own constraint, or the rule is `recorded` as target-enforced.
-- **Rebuild**: a view rebuilt from all facts must give the same rows. Mappings from
-  `$eventContext.occurred` or other occurrence data cannot be executed:
-  the reference runner refuses every event-context path except the event source id
-  (`UnsupportedEventContext`), so specifications that reach that projection report unsupported. `given clock` does not change that; it supplies `$context.occurred`
-  to command productions only. Record such projection cases as capability gaps (keep the
-  mapping and the intended spec in design mode).
+- **Rebuild**: a view rebuilt from all facts must give the same rows. The reference runner
+  refuses every event-context path except the event source id and, from Screenplay 4.254.0,
+  `$eventContext.occurred` in `from`, `every` and `children` blocks
+  (`UnsupportedEventContext` otherwise). `occurred` executes only for a fact appended during
+  the run under `given clock` (`when append` or a command's production); a `given` fact
+  carries no occurrence time and the specification reports unsupported. Record the
+  remaining cases as capability gaps (keep the mapping and the intended spec in design mode).
 - **Corrections and backdated facts**: a correction is a new fact; specify the view after it.
   If a fact carries a business date earlier than its occurrence, specify which date the view
   shows.

package/package/corpus/skills/cratis-screenplay-scenario-coverage/verification.json

@@ -10,7 +10,7 @@
     { "kind": "skill-contains", "value": "Once, idempotent, exactly once are different claims" },
     { "kind": "skill-contains", "value": "Unauthorized is never `then error`" },
     { "kind": "skill-contains", "value": "find-specification-obligations" },
-    { "kind": "skill-contains", "value": "false PLAY0285" },
+    { "kind": "skill-contains", "value": "A specification runs only its own slice." },
     { "kind": "skill-contains", "value": "One behaviour per spec" },
     { "kind": "skill-contains", "value": "No command has only two specs" },
     { "kind": "skill-contains", "value": "not scenario-complete" },

package/package/corpus/skills/cratis-screenplay-slice-design/references/read-model-design.md

@@ -280,7 +280,7 @@ module Berths
       screen OpenBooking
         title "Open booking"
         data OpenBooking via query OpenBookingById
-        action CancelBooking
+        action CancelBooking for item
       specification CancelledBookingLeavesTheList
         given caller
           authenticated

package/package/corpus/skills/cratis-screenplay-slice-design/references/slicing.md

@@ -83,7 +83,7 @@ module Moorings
       query WaitingRequests => WaitingRequest[]
       screen WaitingListPage
         data WaitingRequest via query WaitingRequests
-        action AssignBerth
+        action AssignBerth for item
     slice StateChange AssignBerth
       command AssignBerth
         berthRequestId BerthRequestId identifier

package/package/corpus/skills/cratis-screenplay-slice-design/references/worked-example.md

@@ -121,8 +121,8 @@ module Lockers
           column number   label "Locker"
           column volume     label "Volume (l)"
           column assigned label "Taken"
-        action InstallLocker
-        action AssignLocker
+        action InstallLocker for screen
+        action AssignLocker for item
       specification RefusingAnAnonymousLockerLookup
         given caller
         then query LockerById
@@ -273,7 +273,7 @@ module Lockers
       screen MyRequest
         title "My locker request"
         data RequestStatus via query RequestById
-        action RequestLocker
+        action RequestLocker for screen
       specification FollowingARequestToAssignment
         given caller
           authenticated

package/package/corpus/skills/cratis-screenplay-specifications/SKILL.md

@@ -186,8 +186,10 @@ Read [references/actions-beyond-commands.md](references/actions-beyond-commands.
 
 ## Reactions and cascades (ESM v6)
 
-From ESM v6 every action sets reactions off and `then` events compare every new fact, the action's and the reactions'. A specification whose action is a command goes in the slice that declares the command. A false `PLAY0285` on a cascade under a compiler that stops before ESM v6 is tool skew, not a modeling error: never delete the `then` line to silence it.
-Read [references/reactions-and-cascades.md](references/reactions-and-cascades.md) when a specification's expected events include what a reaction appends, when a cascade, clock tick or invoked command is involved, or when `cratis` reports `PLAY0285` on a model that `screenplay` accepts (it holds the "Version skew: cascades and the false `PLAY0285`" section).
+From ESM v6 every action sets reactions off. A specification runs only the slice that declares it: only that slice's reactions, captures and publications run, and `then` events compare the new facts of that slice. A specification whose action is a command goes in the slice that declares the command and states the command's own events. Another slice's event is `PLAY0285` (unreachable): state it in the slice that produces it. An automation states a command it invokes in another slice with `then invokes <Command>` (ESM v34).
+Read [references/reactions-and-cascades.md](references/reactions-and-cascades.md) when a specification's expected events include what a reaction appends, when a cascade, clock tick or invoked command is involved, or when a compiler reports `PLAY0285` (it holds the "Version skew and `PLAY0285`" section).
+
+A `statemachine` or `workflow` (ESM v36) carries its own specifications with `then is`, `then sends`, `then starts`, `outcome`, `then completes`, `then fails at` and `then waits at`. Read automations-and-translations [state machines and workflows](../cratis-screenplay-automations-and-translations/references/statemachines-and-workflows.md) when specifying either.
 
 ## Published-event specifications (released ESM v9)
 

package/package/corpus/skills/cratis-screenplay-specifications/references/actions-beyond-commands.md

@@ -21,8 +21,10 @@ Event captures use the typed event fixtures and overlay rules in
 
 Use `given clock`, never `given time`, to state the scenario occurrence time and
 assert a value mapped from `$context.occurred`. In a command's `produces`, that
-mapping executes when the scenario has `given clock`. It is not the same as
-`$eventContext.occurred` in a projection, which the execution plan refuses (SKILL.md, "Reference execution — what actually runs").
+mapping executes when the scenario has `given clock`. `$eventContext.occurred` in a
+projection is the fact's occurrence time: the reference runner executes it in `from`,
+`every` and `children` blocks for facts appended during the run under `given clock`, and a
+`given` fact carries none (Unsupported).
 
 **Which tools bind these actions.** A compiler that admits ESM v6 binds the clock, trigger
 and capture actions, and the `Automation` and `Translate` slices, reactions and captures they

package/package/corpus/skills/cratis-screenplay-specifications/references/child-ordering.md

@@ -69,7 +69,10 @@ module Orders
           orderId = "00000000-0000-0000-0000-000000000001"
         then readmodel OrderView
           orderId = "00000000-0000-0000-0000-000000000001"
-          lines = [{"lineNumber":1,"amount":10}]
+          lines
+            item
+              lineNumber = 1
+              amount     = 10
       specification ChildBeforeGivenParent
         given LineAdded
           orderId = "00000000-0000-0000-0000-000000000001"
@@ -79,7 +82,10 @@ module Orders
           orderId = "00000000-0000-0000-0000-000000000001"
         then readmodel OrderView
           orderId = "00000000-0000-0000-0000-000000000001"
-          lines = [{"lineNumber":1,"amount":10}]
+          lines
+            item
+              lineNumber = 1
+              amount     = 10
       specification ParentBeforeChild
         given OrderAdded
           orderId = "00000000-0000-0000-0000-000000000001"
@@ -89,7 +95,10 @@ module Orders
           amount = 10
         then readmodel OrderView
           orderId = "00000000-0000-0000-0000-000000000001"
-          lines = [{"lineNumber":1,"amount":10}]
+          lines
+            item
+              lineNumber = 1
+              amount     = 10
       specification ParentNeverArrives
         given LineAdded
           orderId = "00000000-0000-0000-0000-000000000001"

package/package/corpus/skills/cratis-screenplay-specifications/references/reactions-and-cascades.md

@@ -1,9 +1,22 @@
+## Contents
+
+- Reactions and cascades (ESM v6)
+  - An automation states the commands it invokes (ESM v34)
+  - The public event is stated in the publishing slice
+  - Version skew and `PLAY0285`
+
 ## Reactions and cascades (ESM v6)
 
 From ESM v6 every action sets reactions off: after a command, an append, a clock
 tick, a trigger or a capture record, each new fact runs the reactions to its event,
-and what those append or invoke runs more, until nothing is left. `then` events
-compare every new fact, the action's and the reactions'.
+and what those append or invoke runs more, until nothing is left.
+
+A specification runs only the slice that declares it (Screenplay decision 0115, every
+model and version from Screenplay 4.246.0). Only that slice's reactions, captures and
+outbound publications run; another slice's never do, so their facts cannot appear in
+`then`, read-model or query assertions. `then` events compare the new facts of the
+specification's own slice. A chain across slices is proved link by link: each slice's
+specification states its own link.
 
 ```screenplay expect PLAY0469
 concept InvoiceId : Uuid
@@ -17,16 +30,12 @@ module Collections
           invoiceId = invoiceId
       event InvoiceSent
         invoiceId InvoiceId
-      specification SendingAnInvoiceSchedulesAReminder
-        given clock "2026-10-02T09:00:00Z"
+      specification SendingAnInvoice
         when SendInvoice
           invoiceId = "9c858901-8a57-4791-81fe-4c455b099bc9"
         then InvoiceSent
           for "9c858901-8a57-4791-81fe-4c455b099bc9"
           invoiceId = "9c858901-8a57-4791-81fe-4c455b099bc9"
-        then ReminderScheduled
-          for "9c858901-8a57-4791-81fe-4c455b099bc9"
-          scheduledAt = "2026-10-02T09:00:00Z"
     slice Automation Reminders
       reaction ReminderScheduler
         description "Schedules a reminder when an invoice is sent"
@@ -37,11 +46,25 @@ module Collections
             scheduledAt = $context.occurred
       event ReminderScheduled
         scheduledAt DateTime
+      specification SendingAnInvoiceSchedulesAReminder
+        given clock "2026-10-02T09:00:00Z"
+        when append InvoiceSent
+          for "9c858901-8a57-4791-81fe-4c455b099bc9"
+          invoiceId = "9c858901-8a57-4791-81fe-4c455b099bc9"
+        then ReminderScheduled
+          for "9c858901-8a57-4791-81fe-4c455b099bc9"
+          scheduledAt = "2026-10-02T09:00:00Z"
 ```
 
 - A specification whose action is a command goes in the slice that declares that
   command, here `SendInvoice`, not in the `Automation` slice that reacts: a command
   from another slice is `PLAY0273` "command is unresolved in its slice" at binding.
+  It states the command's own events. The reminder is the `Reminders` slice's link,
+  stated there with `when append InvoiceSent`.
+- Stating another slice's event in a command specification is `PLAY0285` (the
+  outcome is unreachable from the specification's slice) and fails at run time with
+  "Expected N fact(s), got M". Move the expectation to the slice that produces it;
+  never delete the reaction.
 - A reaction invocation without a declared actor has no caller and a gated
   command denies. Reaction `runs as system role "<Role>"` supplies the
   authenticated system actor (ESM v10); `given caller` does not. Each command is
@@ -59,21 +82,47 @@ module Collections
   or mixed effects (`-037`). Single-hop reaction append specs render; deeper appends and
   command specs cascading into reactions remain `-011`. Keep refused scope as gap-fill against this contract: `cratis-screenplay-render-and-gap-fill`.
 
-### A command specification states the public event its slice publishes
+### An automation states the commands it invokes (ESM v34)
+
+When a slice's reaction invokes a command another slice owns, that command is decided
+against the world, so the reaction's `on refused` branches behave as before, but its
+facts belong to the other slice and are not kept. The automation states the hand-over
+with `then invokes`, the command and the values it passes (the complete model is the
+`Reminders` slice in captures-and-reactions `references/complete-examples.md`):
+
+```screenplay excerpt
+specification ClosingAPaidInvoice
+  when trigger PaymentFileArrived
+    invoiceId = "9c858901-8a57-4791-81fe-4c455b099bc9"
+    amount = 120
+  then invokes CloseInvoice
+    invoiceId = "9c858901-8a57-4791-81fe-4c455b099bc9"
+    reason = "paid"
+```
+
+- When a specification states at least one `then invokes`, the invocations the slice's
+  reactions made must match them exactly in count and order (any order under
+  `then events in any order`), comparing only the stated values. A refused invocation
+  counts too. A specification that states none does not compare invocations.
+- `then invokes` selects ESM v34. The Stage spec runner compares it; the Cratis
+  renderer refuses models after v33 with `STAGE-ESM-016`.
+- The invoked command's own events are proved by that command's slice, in its own
+  `when <Command>` specification.
+
+### The public event is stated in the publishing slice
 
-When an outbound Translate slice publishes an event from the private events a command produces, the command's specification
-lists the public event after the private ones (`then ProductPriceChanged` after `then ProductPriceSet`). `PLAY0285` follows the
-outbound projection (decision 0098); the accepted path is proven where the command is. An exact fact count
-fails without it.
+An outbound Translate slice that publishes a public event from private events states it
+in its own `when append <PrivateEvent>` specification. The command that produces the
+private event states only its own events (decision 0115 replaces the earlier rule that
+the command's specification listed the public event).
 
-### Version skew: cascades and the false `PLAY0285`
+### Version skew and `PLAY0285`
 
-`PLAY0285` (a specification's expected event contradicts every producer of its
-`when` command) runs in the syntax pass, with no binding. An older compiler does not trace
-reachability through reactions and `invokes`, so the example above passes `screenplay` (and is
-executable-ready over its MCP server) but fails an older `cratis screenplay validate` with
-`PLAY0285` "Specification outcome 'ReminderScheduled' cannot be produced by 'SendInvoice'",
-exit 5. If an older bundle still reports it, it is a tool skew, not a
-modeling error: do not delete the `then` line or move the event to make `cratis`
-green. Validate with the standalone tool or a current `cratis`, record which tool gave which
+`PLAY0285` (a specification's expected event contradicts every possible producer of its
+`when` command) follows the reactions, invocations and publications declared in the
+specification's own slice. From Screenplay 4.246.0 it refuses another slice's event as
+unreachable, and that is a modeling error: move the expectation to the slice that
+produces the event. A compiler older than ESM v6 does not trace reactions at all and
+can report `PLAY0285` on a reaction in the specification's own slice; that is tool skew.
+Validate with the standalone tool or a current `cratis`, record which tool gave which
 verdict, and see `cratis-screenplay-toolchain`.

package/package/corpus/skills/cratis-screenplay-specifications/references/vocabulary.md

@@ -33,7 +33,8 @@ This reference holds the given/when/then construct table and the enumeration and
 | `then error` | a validation or constraint rejection, reason unnamed |
 | `then denied` | an authorization denial (`Unauthorized`) |
 | `for <value>` | the event source of a `given`/`then` event, or of the `when` command or appended event |
-| `<property> = <value>` | a literal, `null`, or a one-line JSON-shaped object or list: `lines = [{"sku":"A-1","quantity":2}]` |
+| `<property> = <value>` | a scalar literal or `null` |
+| `<property>` with an indented block | an object (`member = value` lines) or a list (one `item` line per element); `<property> none` is an empty list. Screenplay has no JSON: `lines = [...]` is PLAY0833 |
 
 ## Composite-keyed read models
 
@@ -42,7 +43,7 @@ read model with two or more `key` marks, and every specification over it, with P
 
 - `given readmodel` and `then readmodel` state every key part (missing part PLAY0351,
   repeated part PLAY0519).
-- `then no readmodel <Type> for {"part":"value",...}` names every part (missing PLAY0661,
+- `then no readmodel <Type> for`, with one indented `part = value` line per part, names every part (missing PLAY0661,
   unknown PLAY0662, repeated member PLAY0294).
 - `when query` or `then query … arguments` supplies every `by` part of a single-instance
   query, or the equality filters of a list query (missing, unknown or repeated PLAY0468).

package/package/corpus/skills/cratis-screenplay-specifications/verification.json

@@ -77,11 +77,11 @@
     },
     {
       "kind": "skill-contains",
-      "value": "Version skew: cascades and the false `PLAY0285`"
+      "value": "Version skew and `PLAY0285`"
     },
     {
       "kind": "skill-contains",
-      "value": "Specification outcome 'ReminderScheduled' cannot be produced", "file": "references/reactions-and-cascades.md"
+      "value": "never delete the reaction", "file": "references/reactions-and-cascades.md"
     },
     { "kind": "skill-contains", "value": "Examples typed from another document", "file": "references/examples-and-routes.md" },
     { "kind": "skill-contains", "value": "`PLAY0520`", "file": "references/examples-and-routes.md" }

package/package/corpus/skills/cratis-screenplay-toolchain/SKILL.md

@@ -114,9 +114,9 @@ with ordered imports means future files need explicit imports.
   filters, opaque `scoped to` and a `by` block on a list query remain PLAY0268; a `performer` query is an opaque read left out of the executable model (PLAY0270; [version gate](references/executable-subset.md#code-attachments-what-binds-what-never-does)). Read
   read-surface [equality filters](../cratis-screenplay-read-surface/references/equality-filters.md).
   Pending handlers beside unconditional productions bind as described commands (v23),
-  but reached bodies are Unsupported; attached file/inline handlers refuse PLAY0800
-  and require constrained implementation attachments (code gap-fill, not future ESM
-  admission).
+  but reached bodies are Unsupported; attached file/inline handlers bind the same way
+  beside unconditional `produces` with a resolved body and otherwise
+  refuse PLAY0800.
   Requires Screenplay 4.210.0 (`screenplay --version`); older binders use PLAY0268 for this refusal. Read `arguments.subject`, not the message, for the command.
   Eligible protected reads opt into v25; legacy reads and `concurrency` retain PLAY0271.
   Concept compliance binds as v13 (precise refusals: command-surface `references/compliance.md`);

package/package/corpus/skills/cratis-screenplay-toolchain/references/automation-translate-example.md

@@ -1,6 +1,6 @@
 # Automation and Translate example (ESM v6)
 
-Executable Automation and Translate slices. Binds as `executableReady` on the standalone tool and on the compiler bundled in the CLI; see [executable-subset.md](executable-subset.md) for what renders. Shows a reaction `produces` cascade, `invokes`, `where`, clock `at`, an application trigger, a capture with translate and a transition `when`, and v6 specifications.
+Executable Automation and Translate slices. Binds as `executableReady` (ESM v34, for `then invokes`) on the standalone tool and on a CLI whose bundled compiler is Screenplay 4.246.0 or later; see [executable-subset.md](executable-subset.md) for what renders. Shows a reaction `produces` cascade, `invokes`, `where`, clock `at`, an application trigger, a capture with translate and a transition `when`, and v6 specifications. Each specification states only its own slice (Screenplay decision 0115); the automation states the command it invokes with `then invokes` (ESM v34).
 
 The `Renew` command is ungated so that the reaction can invoke it: this is a syntax demonstration, not a safe production design. Reactions invoke with no caller, so a real model needs a trusted path (see [cratis-screenplay-automations-and-translations](../../cratis-screenplay-automations-and-translations/SKILL.md)).
 
@@ -23,12 +23,9 @@ module Membership
         given clock "2026-10-05T09:00:00Z"
         when Subscribe
           memberId = "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
-        then MemberSubscribed                             // v6: cascades are part of `then`
+        then MemberSubscribed                             // its own slice only: Onboarding states WelcomeSent
           for "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
           subscribedAt = "2026-10-05T09:00:00Z"
-        then WelcomeSent
-          for "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
-          sentAt = "2026-10-05T09:00:00Z"
 
     slice StateChange Renew
       command Renew                                       // ungated for the demo only: reactions invoke with no caller
@@ -78,9 +75,9 @@ module Membership
         when trigger RenewalFileArrived
           memberId = "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
           months   = 12
-        then MembershipRenewed
-          for "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
-          months = 12
+        then invokes Renew                                // ESM v34: the hand-over; Renew's slice proves MembershipRenewed
+          memberId = "5b6c1f7e-2d3a-4e8b-9c0d-1a2b3c4d5e6f"
+          months   = 12
       specification IssuingTheWeeklyReport
         given clock "2026-10-05T07:00:00Z"
         when clock "2026-10-05T07:30:00Z"