@cratis/pi 7.62.0 → 7.63.0

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/realization-and-gap-fill.md

@@ -22,6 +22,11 @@ recovery behavior rather than assuming this handler supplies all-or-nothing sett
 rejected model renderable, and never claim a whole-application V5 from a subset. Choose the route
 with `cratis-screenplay-render-and-gap-fill`.
 
+Application-root `reaction batches atomic` also blocks Stage delivery: v22
+refuses STAGE-ESM-016; mode in admitted v23–v25 refuses STAGE-ESM-043. Preserve the
+per-occurrence/selected-branch batch boundary and independent invoked commands.
+Atomic appends do not prove redelivery deduplication or external exactly-once effects.
+
 ## Where the pieces go (hand-written)
 | Model element | Realization | Skill |
 |---|---|---|

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/todo-list-example.md

@@ -188,7 +188,7 @@ module Certification
 ## Design-only additions
 
 Two things a real queue often wants stay out of the complete model above: a list query (the
-visible queue) and a retry sweep that reads the whole view. The list query binds (Stage refuses a snapshot list); the sweep needs a code body the
+visible queue) and a retry sweep that reads the whole view. The list query binds (Stage renders snapshot and observable lists); the sweep needs a code body the
 reference does not run, and durable per-item fan-out is outside the language. Say so
 in the verdict.
 

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/translate-example.md

@@ -1,7 +1,12 @@
-# Example: a Translate slice
+# Example: a capture and its follow-up Automation
+
+## Contents
+
+- Model
+- Notes for the reader
 
 A complete model: a webhook record from an outside proctoring service is captured, kept as an
-external fact in the provider's vocabulary, then translated by reactions into our facts. It
+external fact in the provider's vocabulary, then followed by a separate Automation that records our result. It
 binds as ESM v6 (`executableReady: true`), standalone and through `cratis screenplay mcp`; a
 compiler that stops before v6 compiles it (V1) but rejects the Translate slice at binding
 (PLAY0268). `cratis render` refuses it (`STAGE-ESM-016` or `STAGE-ESM-024`, by renderer).
@@ -10,6 +15,8 @@ Read the slice `description`: it is the per-field disposition (map, translate, i
 states what this example does not do. Examples never show the whole integration contract; use
 `references/integration-contracts.md` and `references/worked-integration.md` for the rest.
 
+## Model
+
 ```screenplay
 // Translate slice. Correlation is created on OUR side: BookExam allocates the attempt id and the
 // realization hands it to the proctoring service as its reference; the service's webhook echoes
@@ -57,7 +64,7 @@ module Exams
         then denied
 
     slice Translate ImportProctorResults
-      description "Per external field: reference -> correlation key (our attempt id, echoed); outcome -> translated to our enum; score -> kept; examinerNote -> ignored (free text, may hold personal data, no consumer). Repeated delivery: the first record of a key appends once (`when added`, Chronicle's first-observation rule); a later delivery of the same key appends nothing, even if the outcome or score changed, so it does not implement corrections. OneResultPerAttempt refuses a second local result. Changed outcomes and score-only corrections need an explicit correction policy (open decision, recorded in STATE.md, not an overwrite) before this is a complete integration."
+      description "Per external field: reference -> correlation key (our attempt id, echoed); outcome -> translated to our enum; score -> kept; examinerNote -> ignored (free text, may hold personal data, no consumer). Repeated delivery: the first record of a key appends once (`when added`); later records compare outcome only. An unchanged outcome appends nothing, even if the score changed, so it does not implement score corrections. OneResultPerAttempt refuses a second local result. Changed outcomes and score-only corrections need an explicit correction policy (open decision, recorded in STATE.md, not an overwrite) before this is a complete integration."
       capture ProctorResults
         source webhook
           path /webhooks/proctoring/results
@@ -70,15 +77,13 @@ module Exams
           when added
             outcome = $.outcome
             score   = $.score
+        append ProctorResultReceived
+          when outcome
+            outcome = $.outcome
+            score   = $.score
       event ProctorResultReceived
         outcome ProctorOutcome
         score   Int
-      event ExamPassed
-        score Int
-      event ExamFailed
-      constraint OneResultPerAttempt
-        unique event ExamPassed
-        unique event ExamFailed
       specification TranslatingAPass
         when capture ProctorResults
           reference = "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
@@ -91,18 +96,7 @@ module Exams
         then ExamPassed
           for "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
           score = 87
-      specification RefusingASecondResult
-        given ExamPassed
-          for "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
-          score = 87
-        when append ProctorResultReceived
-          for "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
-          outcome = "failed"
-          score   = 40
-        then error "Constraint 'OneResultPerAttempt' is violated: the event source already has the constrained event."
-
-    slice Automation TranslateProctorResults
-      description "Our facts from the provider's: the translators react to the external fact the Translate slice records"
+    slice Automation RecordExamResult
       reaction PassTranslator
         when ProctorResultReceived
           outcome
@@ -115,11 +109,33 @@ module Exams
           outcome
           produces ExamFailed
         where outcome == "failed"
+      event ExamPassed
+        score Int
+      event ExamFailed
+      constraint OneResultPerAttempt
+        unique event ExamPassed
+        unique event ExamFailed
+      specification RefusingASecondResult
+        given ExamPassed
+          for "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
+          score = 87
+        when append ProctorResultReceived
+          for "7e9d1c2b-4a3f-4e5d-8c6b-1a2b3c4d5e06"
+          outcome = "failed"
+          score   = 40
+        then error "Constraint 'OneResultPerAttempt' is violated: the event source already has the constrained event."
 ```
 
-Notes for the reader:
+## Notes for the reader
 
-- A capture and the external fact it appends stay in the `Translate` slice; the translator reactions that answer that fact sit in an `Automation` slice beside it (a reaction in the capture's own directionless `Translate` slice is `PLAY0694`). `then` lists every new fact, so `TranslatingAPass` names both the external fact and ours.
+- Keep the capture and its appended event in Translate; put reactions to that local
+  event in a separate Automation. Co-location in a directionless Translate warns
+  PLAY0694 and fails `--warnaserror`; explicit inbound refuses it with PLAY0616.
+  `then` lists every new fact, so `TranslatingAPass` includes the Automation result.
+- `when added` records first sight; the separate `when outcome` append handles
+  later changes. For an update spec, seed the same reference with `given capture`.
+  Requires Screenplay 4.175.0 or later (`screenplay --version`); older evaluators
+  treat a first record's fields as changed.
 - The unauthenticated-booking spec needs an explicit `given caller` (empty means no caller);
   an authorized command exercised without one is PLAY0389 at binding.
 - Authenticity of the webhook, tenant ownership and a score-correction policy are not in the

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/translation-patterns.md

@@ -1,5 +1,15 @@
 # Translation patterns
 
+## Contents
+
+- 1. Where outside facts may enter
+- 2. Correlation first
+- 3. Two vocabularies
+- 4. Per-field disposition
+- 5. Dedup and ordering
+- 6. Corrections from outside
+- 7. Specifying translations
+
 Complete compiled example: `translate-example.md` (binds as ESM v6; a compiler that stops before v6
 compiles it but rejects the slice at binding).
 
@@ -7,8 +17,15 @@ compiles it but rejects the slice at binding).
 Only two routes, both in a `Translate` slice:
 - **`capture`** over a source (api poll, webhook, message topic): key, map, conditional
   appends. Change detection compares each record with the last one seen for the same key.
-- **translator `reaction`** over an event imported from another context (unquoted
-  `import Context.Event`) or over the external fact a capture appended.
+- **translator `reaction`** over a foreign public event declared with its origin.
+  Opaque unquoted imports do not bind. A reaction to a local event a capture
+  appended is a follow-up Automation in a separate slice, not another translation.
+
+A directionless Translate with an unrouted reaction to its own capture's appends
+(including children/nested) warns PLAY0694 and fails `--warnaserror`; explicitly
+inbound local-event consumption is PLAY0616. Keep the capture in Translate and
+choose a separate Automation slice and its specs; there is no automatic repair.
+Requires Screenplay 4.176.0 or later (`screenplay --version`) for PLAY0694; older compilers leave the directionless shape unchecked.
 Not a translation: our own event-to-event follow-up (Automation), infrastructure plumbing,
 and raw database row changes published as-is.
 
@@ -25,8 +42,8 @@ thing by it. Keep it as a property when it is needed to correlate or deduplicate
 ## 3. Two vocabularies
 - The capture appends an **external fact** in the provider's terms (`ProctorResultReceived`
   with a translated `outcome`).
-- Translator reactions record **our facts** in business terms (`ExamPassed`, `ExamFailed`),
-  each guarded by our constraints.
+- Reactions to that local fact record further **our facts** (`ExamPassed`, `ExamFailed`)
+  in a separate Automation slice, each guarded by our constraints.
 - A further worker needs a distinct local decision, obligation or external effect; otherwise
   project views from our fact directly.
 - Name our facts for what they mean to us, not for the transport (`<X>Synced`,
@@ -78,11 +95,17 @@ is a new fact for us (`ResultCorrected`), never an overwrite. Mutually exclusive
 event with `released by` or a separate correction flow is right.
 
 ## 7. Specifying translations
-- `when capture <Capture>` with record fields (as the source names them) -> `then` the
-  external fact and, under v6, what translator reactions appended (`then` lists every new
-  fact).
-- `given capture` for the previous record when a condition compares (`from … to …`,
-  unchanged redelivery).
-- `when append <ExternalFact>` -> `then <OurFact>` to test a translator reaction alone.
-- Case list: `cases-to-specify.md`. These forms parse (probed in
-  `translate-example.md`) but are not executed by any local engine.
+- Record sources: `when capture <Capture>` with source fields -> `then` every new
+  fact, including follow-up Automation appends. A first record of a key is added
+  only: use a separate `when added` append for first sight, keeping the field guard
+  for updates. Seed updates with `given capture` of the same key. Child/nested
+  additions follow the same rule; expressions, maps and unguarded appends are unchanged.
+  Requires Screenplay 4.175.0 or later (`screenplay --version`); older evaluators
+  treat first-record fields as changed.
+- Event sources: `given <FromEvent>` / `when append <FromEvent>`, never capture
+  records (PLAY0701). The key is required on every source event (PLAY0700).
+  Read [public event captures](public-events-and-direction.md) for executable examples,
+  overlay semantics and their prerequisite.
+- `when append <LocalFact>` -> `then <OurFact>` tests the follow-up Automation alone.
+- Run admitted cases with `screenplay test <model>`; all selected specs must pass.
+  Case list: `cases-to-specify.md`.

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/SKILL.md

@@ -26,30 +26,22 @@ Language claims follow Screenplay `reactions.md`, `triggers.md`, `captures.md` a
 `Documentation/reference/reaction-rendering.md`. Tool versions are covered in toolchain
 `SKILL.md`; run the examples at the pinned standalone tool before relying on them.
 
-⚠️ **Which tool admits them depends on its Screenplay version.** The ESM level
-decides, not the slice type:
-
-- **A compiler that admits ESM v6 and v7:** `Automation` and
-  `Translate` slices, reactions, declared triggers and captures bind, and the
-  reference runner executes them. The complete example below is
-  `executableReady` over `screenplay mcp`.
-- **A compiler that stops before ESM v6** refuses them and falsely reports PLAY0285
-  (toolchain `references/diagnostics.md`).
+The compiler's ESM admission decides, not the slice type. Reactions, triggers and
+captures bind/reference-execute from v6; older compilers refuse them. Read toolchain
+`references/diagnostics.md` when diagnosing skew or false PLAY0285 cascades.
 - **The CLI and Stage** render supported event-triggered Automation, not
   Translate/captures, non-event triggers or opaque bodies (`-024`). Role/authenticated `runs as`
   and semantic `from` render; claim/opaque gates, mixed effects and unsupported mappings remain refused;
   cascade specs remain `-011`. Keep refused scope as gap-fill. Full boundary and source
   citations: `cratis-stage-rendering-and-sandbox` `references/admission.md`.
 
-Model them whenever the `.play` file is the deliverable, and say which tool bound
-them (`cratis-screenplay-toolchain` `references/diagnostics.md` for messages).
-Method (the four-part automation test, loops, translations versus automations):
-`cratis-screenplay-automations-and-translations`.
+Name the binding tool. For the automation test, loops and translation boundaries,
+read `cratis-screenplay-automations-and-translations`.
 
 ## Public boundaries and observer selection
 
 Read [ESM v9 translation](../cratis-screenplay-automations-and-translations/references/public-events-and-direction.md)
-for `direction`, `source events`/`from`, and its typed Unsupported evaluation.
+for `direction`, `source events`/`from`, typed event fixtures and per-key state folds.
 One `source events` capture consumes events from exactly one origin (event store).
 Split inputs from several external systems into one capture per origin; otherwise
 PLAY0687 reports an error, matching Chronicle's one-inbox-observer boundary.
@@ -60,12 +52,31 @@ for reaction/reducer `from Source[.Stream]`; unrouted facts never match.
 
 ## Specify what sets them off
 
-A specification names what sets the automation off: `when clock`, `when trigger`
-or `when capture`. Execute admitted scenarios through `screenplay test` or MCP
-`run-specifications`; source compilation alone is only authored evidence.
+A specification names its input: `when clock` or `when trigger` for an automation,
+`when capture` for a record source, and `when append <ForeignEvent>` for a capture
+with `source events`. Seed the latter with `given <ForeignEvent>`, never `given capture`
+or `when capture` (PLAY0701). Its key must be a required property of every `from`
+event, never `$eventSourceId` or another context key (PLAY0700).
+
+Requires Screenplay 4.171.0 or later (`screenplay --version`) for reference execution of captures over events and PLAY0700/0701; older tools leave event delivery unexecuted.
+
+First sight is `added` only, not a field change. Read
+[record capture specifications](references/record-capture-specifications.md) when
+specifying first sight, updates, child/nested additions or unchanged records.
+Execute admitted scenarios through `screenplay test` or MCP `run-specifications`;
+source compilation alone is only authored evidence.
 
 Read [references/specifying-triggers-and-clock.md](references/specifying-triggers-and-clock.md) when writing a specification for a reaction, trigger or capture, or when the clock, occurrence or limit rules matter.
 
+## Atomic batches and event-source mappings
+
+Start new models with application-root `reaction batches atomic`. One trigger's direct
+productions, or one selected refusal branch, append all-or-none; invoked commands stay
+separate. Legacy models without opt-in retain per-fact appends even at newer versions.
+Read [atomic batches and source mappings](references/atomic-batches-and-source-mappings.md)
+for batch failure assertions, PLAY0693, Stage STAGE-ESM-016/043 refusals and
+`invokes` mappings from `$eventSourceId` / `$eventContext.eventSourceId`.
+
 ## Caller-less invokes and unprotected reads
 
 **Who is the caller of an `invokes`?** Without a declared actor, nobody.
@@ -90,7 +101,10 @@ ESM v6 the binder refuses to treat it as one: a trigger with `reads` that **prod
 directly**, or whose effect is an opaque body (`file` or an inline block), fails
 binding, because its decision dependency cannot be protected. A reaction that only
 `invokes` a command binds, and the decision, and any protection, belong to that
-command's own reads. Command `reads` give none yet either (`PLAY0271`).
+command's own reads. Eligible command reads protect under application-root
+`command reads protected` (ESM v25); legacy reads retain PLAY0271. Read command-surface
+[protected reads](../cratis-screenplay-command-surface/references/protected-reads.md)
+for admission and absence/conflict behavior. Stage admits v25 but refuses protected reads with STAGE-ESM-044.
 `where` over read paths out of scope, and `where` needs
 every operand to resolve from the trigger's declared scalar occurrence shape (listed in
 the input selection or not; nested paths and read aliases fail binding): keep the logic that uses the state in
@@ -123,25 +137,13 @@ The full capture excerpt (`source`, `key`, `map` with `translate`, two `append`
 
 Read [references/capture-map-and-example.md](references/capture-map-and-example.md) when writing a capture's `map` block, or when you need the excerpt of a capture with `append` and `children`.
 
-**`source <kind>`** takes free-form settings, so a typo is not caught; **`key <property>`** is required to bind (`PLAY0268`); **`append <Event>`** takes one `when` clause, and `or` and `and` cannot be mixed in one clause (split into two `append` blocks). Read [references/capture-map-and-example.md](references/capture-map-and-example.md) for source kinds, `key` and specification behavior, the `when` forms table, `children` and `nested`.
+**`source <kind>`** takes free-form settings, so a typo is not caught; **`key <property>`** is required to bind (`PLAY0268`); **`append <Event>`** takes at most one `when` clause, and `or` and `and` cannot be mixed in one clause (split into two `append` blocks). Read [references/capture-map-and-example.md](references/capture-map-and-example.md) for source kinds, `key` and specification behavior, the `when` forms table, `children` and `nested`.
 
 ## `reaction`
 
-Excerpt; complete document: `references/complete-examples.md`,
-"Reaction on a declared trigger with `where` and `invokes`".
-
-```screenplay excerpt
-slice Automation NotifyOnBuildFailure
-  reaction NotifyOnFailure
-    description "Tells the owning team when a watched build fails"
-    when BuildFinished
-      repository
-      outcome
-      invokes SendFailureNotice
-        repository = repository
-        outcome    = outcome
-    where outcome == "failed"
-```
+Read [reaction forms](references/reaction-forms.md) when choosing a trigger,
+selecting occurrence values or mapping `produces` and `invokes`; complete documents
+remain in `references/complete-examples.md`.
 
 A reaction declares **at least one trigger**; everything under a trigger is
 optional.
@@ -152,29 +154,13 @@ under `when`/`every`/`at`. `description`, `where` and `runs as` sit at reaction
 Outdenting an effect gives *Expected a trigger in reaction body, got 'invokes …'*
 (`PLAY0137`) — the compiler is looking for another trigger where the effect is.
 
-### What sets it off
-
-| Form | Runs |
-| --- | --- |
-| `when <Name>` | on that event, declared trigger, or registered trigger |
-| `every <n> seconds\|minutes\|hours\|days` | on that interval (`n` ≥ 1) |
-| `at HH:mm` | every day at that time |
-| `at HH:mm on <Weekday>` | every week on that day |
-| `at HH:mm on day <n>` | every month on that day (`n` is 1–31) |
-
-Time is strictly `HH:mm`. Weekday is the full English name.
-
-### The values a reaction takes
-
-A bare name under a trigger says the reaction **uses** that value from the
-occurrence. This is a **selection, not a declaration** — the shape belongs to the
-event or trigger. Taking a value the occurrence does not carry is reported.
-
 ### `where` — narrowing
 
 `where` uses the same condition grammar as `produces … when` and `require`:
 `==`, `!=`, the ordering operators, `contains` for a substring anywhere,
 `starts with` for one at the beginning, combined with `and`, `or` and parentheses.
+These text-condition operators parse but refuse executable binding (PLAY0268);
+literal property text rules are a separate v24 contract.
 
 ⚠️ **`where` belongs to the reaction, not to one trigger** — it says which
 occurrences are worth running for, whatever set them off. A second `where` on one
@@ -186,36 +172,16 @@ Inline `produces event <Name>` is command-only (`PLAY0474` in a reaction).
 Declare reaction-produced events separately and use plain `produces <Name>`.
 Do not extend the inline command destination default or its repairs to reactions.
 
-Excerpt; complete document: `references/complete-examples.md`,
-"Reaction with `produces` and `invokes`":
-
-```screenplay excerpt
-reaction Provisioner
-  when InvitationAccepted
-    workspaceId
-    produces WorkspaceProvisioned
-      for workspaceId
-      workspaceId = workspaceId
-    invokes SendWelcomeMail
-      workspaceId = workspaceId
-      template    = "welcome"
-```
-
 A `produces` without `for` appends to the event source of the event that set the
 reaction off. A clock, application or built-in trigger has no such event, so what it
 produces needs `for` - a value the trigger carries, or literal text.
 
-**The different word is the point.** `produces` requests a fact append, subject to
-append-time constraints. `invokes` asks for a command, which additionally runs the
-command's authorization, validation and requirements, and may reject.
-Using `produces` for both would say those are the same kind of consequence.
+`produces` requests an append; `invokes` also runs command gates and may reject.
 
 **Who is the caller of an `invokes`?** Nobody unless `runs as` declares the actor; see *Caller-less invokes and unprotected reads* above before writing one.
 
-Both are declarations of *what happens*, not of how — a trigger can state its
-consequences **and** carry a `file` or an inline block in a tagged fence
-(` ```csharp `) that implements them. That code is an implementation attachment:
-the model lists it (role, owner, content hash) but never runs it.
+Trigger `file`/tagged-code attachments are inventoried, never reference-executed;
+see the reaction forms reference for their boundary.
 
 ### What it decides from — trigger `reads`
 
@@ -237,11 +203,15 @@ Read [references/trigger-reads-example.md](references/trigger-reads-example.md)
 
 A `trigger` declares that a name exists and what an occurrence hands the reaction, never what makes it occur. Built-ins are `Startup` and `Shutdown`. An unknown name warns `PLAY0248`; **An application trigger is not a UI event** (`PLAY0326`); under a reaction trigger, values named `description`, `file`, `produces`, `invokes` or `reads` are written with `@`. Read [references/trigger-declaration.md](references/trigger-declaration.md) when declaring or registering a trigger or resolving a trigger name.
 
-## Guidance, verbatim
+## Slice boundaries
+
+Requires Screenplay 4.176.0 or later (`screenplay --version`) for PLAY0694; older compilers leave directionless capture-follow-up co-location unchecked.
 
-> - Reactions that only translate events into other events belong in `Translate`
->   slices when driven by external data (captures); event-to-event automation stays
->   in `Automation` slices.
+> - A capture belongs in `Translate`; a reaction to the local event it appends
+>   belongs in a separate `Automation` slice. A directionless Translate containing
+>   both warns PLAY0694 (fails `--warnaserror`); explicit inbound refuses it with
+>   PLAY0616. A reaction translating a foreign public event can belong in inbound
+>   Translate.
 > - Keep reaction logic small; anything substantial belongs in a `file` reference
 >   where it can be tested on its own.
 > - Describe the reaction before you implement it — a document full of `file` lines
@@ -267,8 +237,8 @@ A `trigger` declares that a name exists and what an occurrence hands the reactio
 - [ ] Every name a reaction takes is carried by the event or trigger.
 - [ ] Each trigger `reads` the views its automation decides from; `by` names a
       value the trigger takes, and clock triggers read without `by`.
-- [ ] Nobody reports trigger or command `reads` as protected; UI clicks are
-      interactions, not triggers.
+- [ ] Trigger reads are not protection; protected command reads require opt-in,
+      admission and separate target realization. UI clicks are interactions.
 - [ ] Every gated invocation declares its trusted actor with reaction `runs as`
       (ESM v10) or records the target gap explicitly; `given caller` is not that actor.
 

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md

@@ -0,0 +1,83 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Atomic reaction batches and event-source invocation mappings
+
+## Choose the batch boundary
+
+Requires Screenplay 4.181.0 or later (`screenplay --version`) for atomic batches; older compilers cannot admit the declaration.
+
+Start new models with application-root `reaction batches atomic`, before declarations.
+Declare it once per composed application; imports inherit it. It selects ESM v22 or
+later even before the first reaction. Duplicate, conflicting or invalid declarations
+report PLAY0693. Do not automatically repair by removing it: that changes semantics.
+
+One trigger occurrence's direct `produces` list is one all-or-none batch. Each selected
+invocation-refusal branch's productions form another batch. Invoked commands retain
+their own atomic appends; neither separate triggers nor occurrences are combined.
+This is not a transaction around the cascade.
+
+Candidates are materialized and append-validated before private projections and
+publications. Primary facts are adopted first, then derived publications; only adopted
+facts start cascades. The complete expanded result must fit the 1,000-new-fact budget
+before adoption; given history does not count. A failed batch leaves its pre-batch
+facts, read models and pending children unchanged. Earlier accepted batches/commands
+remain. Violation order is authored production order, then ordinal constraint name;
+SemanticRejected.Production carries the zero-based index, event contract and route.
+Property-value reservations within a batch are not freed when a source changes value;
+the same source may repeat its own claim.
+
+Without the preamble, per-fact production remains legacy behavior, even at a higher
+ESM version. Recompiling never opts an existing model in. Review migration explicitly.
+Atomic batching does not admit direct-production stream routes or closing constraints,
+deduplicate redelivery, promise atomic observer snapshots or resolve unknown storage
+outcomes. `then error` alone is insufficient: also assert no facts from the failed
+batch and unchanged read models with evaluator world/read-model assertions; earlier
+accepted work can remain. `then no events` means accepted zero outcomes and cannot
+accompany `then error`. Do not invent a mixed success/error specification form.
+
+Stage refuses ESM v22 with STAGE-ESM-016. Even an admitted v23–v25 model carrying
+atomic mode is refused with STAGE-ESM-043 by renderer, Host and specification executor.
+Keep the declaration and report authorized gap-fill; do not promise a render date or
+strip atomicity to lower the version.
+
+MCP `describe-application` reports `reactionProductionMode` and
+`reactionProductionReadiness`; ApplicationSyntax.reactionProductionMode is Atomic.
+Source/AST proposals preserve it; readiness is not target realization.
+
+## Map the triggering event source
+
+Requires Screenplay 4.197.1 or later (`screenplay --version`) for event-source `invokes` mappings; older compilers refuse them with PLAY0268.
+
+Use context identity rather than duplicating an event source in event payload.
+Complete model (atomic mode deliberately retained despite Stage's refusal):
+
+```screenplay
+domain Orders
+reaction batches atomic
+module Fulfillment
+  feature Packing
+    slice StateChange PackOrder
+      command PackOrder
+        orderId String identifier
+        produces OrderPacked
+          for orderId
+      event OrderPacked
+    slice Automation PackPlacedOrder
+      event OrderPlaced
+      reaction PackPlacedOrder
+        when OrderPlaced
+          invokes PackOrder
+            orderId = $eventSourceId
+```
+
+`$eventContext.eventSourceId` is equivalent. The source also works in reaction
+`produces` mappings. The target must be a required scalar; reference execution checks
+the value against that target type without conversion. Clock/application triggers
+have no event source. This is neither clock context nor caller/audit identity and
+does not select a new ESM version: it uses the reaction v6 mapping contract.
+Keep authorization and a trusted reaction `runs as` where the invoked command is gated.
+
+Run `screenplay <root> --warnaserror` and `screenplay test <root>`; expect source
+validation and admitted scenarios to pass separately. A Stage refusal remains a
+separate result even when both Screenplay checks pass.

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/capture-map-and-example.md

@@ -49,10 +49,13 @@ convention, not enforcement. `source events` (`from <Event>` lines, ESM v9) is t
 its own closed grammar (PLAY0610/0612/0616/0619/0620).
 
 **`key <property>`** names the source property identifying an instance. From ESM v6
-a capture without a `key` does not bind (`PLAY0268`). In a specification the
+a capture without a `key` does not bind (`PLAY0268`). For record sources the
 reference is handed records (`given capture`, `when capture`) and never contacts a
-`source`, which stays realization metadata; events append to the event source the
-record's `key` names, and `$context.occurred` is the scenario's `given clock`.
+`source`, which stays realization metadata. For `source events`, present a declared
+`from` event with `given <Event>` / `when append <Event>` (PLAY0701 otherwise);
+`key` must be a required property of every source event, not a context key
+(PLAY0700). Events append to the event source the key names, and
+`$context.occurred` is supplied by the scenario's `given clock`.
 
 An event's external origin is declared on the `event` itself with `event X from "<origin>"` (ESM v9);
 outside records still enter through a `capture` in a `Translate` slice
@@ -60,7 +63,14 @@ outside records still enter through a `capture` in a `Translate` slice
 
 **`map`** reshapes properties before events are appended (rename, template, `translate`, `split`; mapping sources are `$.`, `$context.` and `$env.`); syntax is in the reference file linked above.
 
-**`append <Event>`** with optional `tag` lines and one `when` clause:
+**First observation is added only**, at root, child and nested levels. Field-change
+and transition guards need a previous record of the same key (`given capture`), or
+earlier typed events for `source events`. Use a separate `when added` append for
+first sight; keep the field guard for updates. Maps, expression guards and unguarded
+record appends are unchanged. Complete runnable record cases:
+[record-capture-specifications.md](record-capture-specifications.md).
+
+**`append <Event>`** takes optional `tag` lines and at most one `when` clause:
 
 | `when` form | Appends when |
 | --- | --- |

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/reaction-forms.md

@@ -0,0 +1,59 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Reaction trigger and effect forms
+
+Excerpts from `complete-examples.md`: "Reaction on a declared trigger with `where`
+and `invokes`" and "Reaction with `produces` and `invokes`".
+
+```screenplay excerpt
+slice Automation NotifyOnBuildFailure
+  reaction NotifyOnFailure
+    description "Tells the owning team when a watched build fails"
+    when BuildFinished
+      repository
+      outcome
+      invokes SendFailureNotice
+        repository = repository
+        outcome    = outcome
+    where outcome == "failed"
+```
+
+| Form | Runs |
+| --- | --- |
+| `when <Name>` | on that event, declared trigger, or registered trigger |
+| `every <n> seconds\|minutes\|hours\|days` | on that interval (`n` ≥ 1) |
+| `at HH:mm` | every day at that time |
+| `at HH:mm on <Weekday>` | every week on that day |
+| `at HH:mm on day <n>` | every month on that day (`n` is 1–31) |
+
+Time is strictly `HH:mm`. Weekday is the full English name. A bare name under a
+trigger selects a value from the occurrence; it is not a new declaration. Taking
+a value absent from the event/trigger shape is reported.
+
+```screenplay excerpt
+reaction Provisioner
+  when InvitationAccepted
+    workspaceId
+    produces WorkspaceProvisioned
+      for workspaceId
+      workspaceId = workspaceId
+    invokes SendWelcomeMail
+      workspaceId = workspaceId
+      template    = "welcome"
+```
+
+A `produces` without `for` appends to the source of the triggering event. Clock,
+application and built-in triggers need an explicit destination. Producing requests
+an append subject to constraints; invoking also runs command authorization,
+validation and requirements and may reject. They are not interchangeable.
+
+These are declarations, not implementations. A trigger can carry a `file` or
+inline tagged fence beside its consequences; the model inventories role, owner
+and content hash but does not execute that attachment. Stage mixed-effect
+refusals and reference unsupported outcomes remain separate checks.
+
+`where` is reaction-level, with only one occurrence allowed; combine conditions
+with `and`/`or`. Its source grammar includes `contains` and `starts with`, but the
+executable binder refuses those operators with PLAY0268. Use the literal property
+rules for validation, not as a way around condition admission.