@cratis/pi 7.61.0 → 7.63.0

package/package/corpus/skills/cratis-fundamentals-concept/SKILL.md

@@ -118,15 +118,23 @@ Sources and the complete shop example: [shop generation](references/shop-generat
 ## Choosing a strategy
 
 The shared shop uses CustomerId (`cus_` + ULID), context-aware OrderId (TypeID),
-InviteCode (NanoID), and secret ApiKey (`Bytes(32)`, `[NotAudited]` in its host).
+InviteCode (NanoID), readable InvoiceNumber (pattern with checksum), random Int64
+TicketNumber and secret ApiKey (`Bytes(32)`, `[NotAudited]` in its host).
 Read [choices, time/tenant context and protection](references/shop-generation.md).
 Requires Fundamentals 7.24.0 for these newer helpers; the earlier
 UUID examples remain supported.
+Requires Fundamentals 7.25.0 for `GenerateValue.Pattern(pattern, checksum)`, its
+`(pattern, context, checksum)` overload, `Integer(minimum, maximum)` and
+`HasValidChecksum(value, checksum)` (`dotnet list package --include-transitive`);
+older packages lack them. Read the shop reference for exact signatures and UTC
+patterns before using them; do not hand-roll checksum or random-range algorithms.
 
 ## When not to generate
 
 Client-supplied identities stay inputs; random generation is not idempotency or
-gapless numbering. UUIDs are not credentials. Byte generation can create a secret
+gapless/sequential numbering. Patterns are readable references, not allocators or
+secrets; check digits catch typos, not forgery. Short codes need collision handling
+and uniqueness/freshness enforcement appropriate to their role. UUIDs are not credentials. Byte generation can create a secret
 in Fundamentals, but audit suppression, authorized delivery and hash storage are separate
 host responsibilities; never treat randomness as protection.
 

package/package/corpus/skills/cratis-fundamentals-concept/references/shop-generation.md

@@ -15,12 +15,14 @@ A shop can use CustomerId (`cus_` + ULID) for
 recognizable time-ordered customer references, OrderId (TypeID) for typed order
 references, InviteCode (NanoID) for opaque invitation references, and ApiKey
 (`Bytes(32)`) for a 256-bit credential. UUID remains the ordinary identity choice;
-encoded bytes make an exact entropy budget explicit. Prefixes add no entropy.
+encoded bytes make an exact entropy budget explicit. InvoiceNumber uses a readable
+pattern with Luhn check digit; TicketNumber uses an inclusive random Int64 range
+for pickup tickets. Prefixes, dates and checksums add no entropy.
 UUIDv7/ULID/TypeID reveal time and are not monotonic within a millisecond.
 An invitation reference here is not by itself permission to join the shop; if
 possession is the authorization mechanism, treat it as a protected credential too.
 
-This complete concept excerpt requires `Cratis.Fundamentals` 7.24.0 or later and,
+This complete concept excerpt requires `Cratis.Fundamentals` 7.25.0 or later and,
 for the ApiKey audit attribute, `Cratis.Arc.Chronicle`. These are
 non-stream references; use `EventSourceId<string>` instead only if a concept
 actually identifies a Chronicle event source.
@@ -49,6 +51,17 @@ public record InviteCode(string Value) : ConceptAs<string>(Value), IGeneratable<
     public static InviteCode New() => new(GenerateValue.NanoId());
 }
 
+public record InvoiceNumber(string Value) : ConceptAs<string>(Value), IGeneratableInContext<InvoiceNumber>
+{
+    public static InvoiceNumber New(GenerationContext context) =>
+        new(GenerateValue.Pattern("INV-{yyyy}{MM}-#{7}", context, Checksum.Luhn));
+}
+
+public record TicketNumber(long Value) : ConceptAs<long>(Value), IGeneratable<TicketNumber>
+{
+    public static TicketNumber New() => new(GenerateValue.Integer(100000, 999999));
+}
+
 [NotAudited]
 public record ApiKey(string Value) : ConceptAs<string>(Value), IGeneratable<ApiKey>
 {
@@ -80,13 +93,39 @@ Do not present a tenant-prefixed custom string as standard TypeID.
 
 Use the context form only for time/tenant-dependent generation. If both interfaces
 are implemented, callers choose context; the interfaces themselves do not dispatch.
-Built-in context overloads reject default Now (`MissingGenerationTime`) and time
-before the Unix epoch. A fixed context fixes the timestamp, not random suffixes.
+Time-ordered built-in context overloads reject default Now (`MissingGenerationTime`)
+and time before the Unix epoch. A fixed context fixes the timestamp, not random suffixes.
+
+Requires Cratis.Fundamentals 7.25.0 for `Pattern`, `Integer`, `Checksum` and
+`HasValidChecksum` (`dotnet list package --include-transitive`); older packages
+lack these helpers. Upgrade deliberately or retain the existing factory.
+
+`GenerateValue.Pattern(string pattern, Checksum checksum = Checksum.None)` is the
+date-free overload; `Pattern(string pattern, GenerationContext context,
+Checksum checksum = Checksum.None)` uses `context.Now` in UTC for date segments.
+A date pattern without context throws `PatternRequiresGenerationContext`;
+default Now on the context overload throws `MissingGenerationTime`.
+Use `#` for digits, `?` for uppercase letters, `*` for letters/digits, positive
+ASCII classes and repeats up to 64. UTC segments are `{yyyy}`, `{yy}`, `{MM}`, `{dd}`.
+The appended checksum uses every preceding ASCII digit, including date digits:
+`Checksum.Luhn` and `Mod11` append one digit, `Mod97` two; Mod11 excludes payloads
+that would need digit 10. Output including suffix is limited to 256 characters.
+
+Generation does not add a validator. Use
+`GenerateValue.HasValidChecksum(value, Checksum.Luhn)` in the concept's validator
+when supplied/stored values must obey the arithmetic too; combine it with shape
+validation. `Integer(long minimum, long maximum)` returns `long`, includes both
+endpoints and supports the full Int64 range with unbiased secure randomness.
+Enforce unique short payload codes at append: randomness alone does not reserve
+one, and event-source freshness does not protect a different payload value.
 
 ## When not to generate
 
 - Client-minted customer/order IDs stay inputs. Do not replace them on retry.
-- Random values supply neither idempotency nor gapless invoice allocation.
+- Random values and readable patterns supply neither idempotency nor gapless/sequential
+  invoice allocation. A legally gapless invoice number needs an allocator.
+- Check digits detect transcription mistakes, not forgery or authorization; patterns
+  are not secrets. Low-entropy codes need explicit collision/uniqueness handling.
 - An ID is not an authentication token or authorization policy.
 - ApiKey is a **secret**, not an event-source ID: event-source IDs are plaintext metadata
   and cannot be encrypted. Use a separate `ApiKeyId` as the identity and keep ApiKey a
@@ -102,7 +141,11 @@ before the Unix epoch. A fixed context fixes the timestamp, not random suffixes.
 
 Fundamentals `Source/DotNET/Fundamentals/Concepts/GenerationContext.cs`,
 `IGeneratableInContext.cs`, `GenerateValue.TimeOrderedStrings.cs`,
-`GenerateValue.RandomStrings.cs`; `Documentation/csharp/generating-values.md`.
+`GenerateValue.RandomStrings.cs`, `GenerateValue.Patterns.cs`,
+`GenerateValue.Numbers.cs`, `Checksum.cs`; at Fundamentals v7.25.0,
+`Documentation/csharp/generating-values/patterns.md`,
+`Documentation/csharp/generating-values/reference.md` and
+`Documentation/csharp/generating-values/context.md`.
 Arc `Source/DotNET/Chronicle/Commands/NotAuditedAttribute.cs`,
 `CommandCausationValues.cs` (command/type/property exclusion only, never
 payload encryption or log protection);

package/package/corpus/skills/cratis-screenplay-automations-and-translations/SKILL.md

@@ -12,37 +12,41 @@ guarantees. Then write it as `Automation` and `Translate` slices that say truthf
 protected, what is only recorded, and who acts. Grammar depth is in
 `cratis-screenplay-captures-and-reactions`; this skill owns the decisions.
 
-**Translation crosses an application boundary:** inbound turns outside data or foreign
-public events into private local facts; outbound publishes private facts as one local public
-event type. Declare `direction inbound|outbound` when public metadata is used; omission
-preserves inbound for translations without a declared direction. Private-to-private follow-up is an
-Automation (`produces` or `invokes`), even when a Chronicle reactor realizes it.
-Read [public events and direction](references/public-events-and-direction.md) for released
-ESM v9 forms, event-target folds, publication specifications and the Unsupported capture limit.
+**Translation crosses an application boundary:** private-to-private follow-up is
+Automation, even if a reactor realizes it. Keep captures in Translate and reactions
+to their local facts in separate Automation slices. Read
+[public events and direction](references/public-events-and-direction.md) when
+choosing direction, folding events or specifying publication: it owns the ESM v9
+forms, PLAY0616 and directionless Translate's PLAY0694 split boundary.
+Requires Screenplay 4.176.0 or later (`screenplay --version`) for PLAY0694; older compilers leave that directionless shape unchecked.
 One `source events` capture reads one origin (event store); split several origins.
 Requires Screenplay 4.155.0 (`screenplay --version`) for PLAY0687; older tools leave it unchecked.
 
-Work in the model first. Code appears only where it is truly needed: the external call, the
-source adapter, the trusted actor, and everything Stage cannot render (below). Session and
-verdict discipline: `cratis-screenplay-modeling-lifecycle`; tools, versions and verdicts V1 to V5:
-`cratis-screenplay-toolchain`. When you add or change a reaction or capture, resolve its input,
-identity, effect and pending-work contract at that point; do not postpone it to the final review.
+Model behavior first; code implements external calls, adapters, actors and refused
+target scope. Follow `cratis-screenplay-modeling-lifecycle` for session discipline
+and `cratis-screenplay-toolchain` for verdicts. Settle input, identity, effect and
+pending-work contracts when changing each reaction/capture, not at final review.
 
 ## Tool and realization facts (read before promising anything)
-- Reactions, clocks, triggers, captures and Automation/Translate slices compile (V1) and bind (V3)
-  as ESM v6: the standalone tool and a CLI whose bundled compiler admits v6. A compiler that
-  stops before v6 reports PLAY0268 at binding: report "V3 blocked: PLAY0268 (ESM v6)" and
-  name the tool, never remove them.
-- The pinned standalone tool runs admitted scenarios through `screenplay test` or MCP
-  `run-specifications`; source validation and render publication do not run V4.
-- A renderer can refuse Automation/Translate members (STAGE-ESM-024) it does not realize.
-  Deliver that scope as authorized gap-fill
-  (`references/realization-and-gap-fill.md`).
-- Reaction `runs as system role "<Role>"` declares an invocation actor (ESM v10).
-  Without it the invoke has no caller. A compiler or renderer that stops before v10
-  rejects the syntax (PLAY0137) or refuses it at render admission (CLI-RENDER-004). The CLI/Stage pair (toolchain
-  `references/renderable-subset.md`) renders role/authenticated reaction identity; claim-reading/opaque gates retain STAGE-ESM-034. Checked model/diagnostics: captures-and-reactions
-  `references/invocation-identity.md`.
+- V1, V3, V4 and target rendering are separate; name the compiler and never remove
+  a refused construct. Run `screenplay test` or MCP `run-specifications` for V4.
+- Read [realization and gap-fill](references/realization-and-gap-fill.md) before
+  promising Automation/Translate delivery (STAGE-ESM-024).
+- Invokes have no caller without `runs as`. Read captures-and-reactions
+  [invocation identity](../cratis-screenplay-captures-and-reactions/references/invocation-identity.md)
+  for the ESM v10 actor and role/authenticated versus claim/opaque admission.
+
+## Atomic production boundaries and source identity
+
+Start new models with application-root `reaction batches atomic` (ESM v22 or later).
+Each trigger occurrence's direct productions and each selected refusal branch are
+separate all-or-none batches; invoked commands remain independent. Absence retains
+legacy per-fact behavior even at later versions. Assert no failed-batch facts and
+unchanged views, not only `then error`. Stage refuses v22 (STAGE-ESM-016) and
+atomic mode in admitted v23/v24 models (STAGE-ESM-043); keep the semantics as gap-fill.
+Read [atomic batches and source mappings](../cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md)
+when choosing these boundaries or mapping an invoked identifier from `$eventSourceId`
+(or `$eventContext.eventSourceId`) instead of copying it into event payload.
 
 ## Effect guarantees and recovery traps
 | Guarantee | What it promises | What can show it |
@@ -102,19 +106,9 @@ of each, and how each record finds our entity (the correlation strategy); and fo
 occurrence, the effect and who acts. Cite existing answers instead of asking again. Missing
 correlation is the most common cause of failed integrations: surface it first.
 
-**Critical questions** (ask one group at a time; follow up from the answer; accept "unsure" as an
-open question, not an invented answer):
-1. **Sources.** "Which systems send us facts? For each: name, record types, channel (webhook, poll,
-   topic, file), format, who authenticates it?" Follow-up per system: "Does the record carry our
-   entity id, or do we need to remember their id against ours?"
-2. **Mapping.** "For the hardest record: does it map directly to one fact of ours, need several
-   facts, or need data we already hold?" Follow-up if not direct: "What do we look up, and what
-   happens when the record arrives before that data exists?"
-3. **Automations.** "What happens on its own after <fact>? Can it fail, wait, or need a person? What
-   do people see meanwhile? Who is allowed to do it?" Follow-up: "What makes it stop? What if it ran
-   twice?"
-4. **Recovery.** "Which records or steps can we not accept, and who fixes them, how, and how does
-   processing resume?"
+Read [integration interview prompts](references/integration-interview.md) when
+sources, mapping, automation ownership or recovery are unsettled. Ask one group at
+a time; treat "unsure" as an open question.
 
 **Unattended:** assume visibly. Record each assumption as a labelled open decision in `STATE.md`
 (`.ai-work/screenplay/<model-slug>/STATE.md`), mark the dependent slice open, never write a mapping
@@ -155,7 +149,8 @@ or actor that nobody confirmed. Read `references/worked-integration.md` when you
 7. **Translate outside facts** (`references/translation-patterns.md`): enter only via `capture` or a
    translator reaction, in a `Translate` slice; correlate first; keep the external fact distinct from
    ours; trace source fields *and* every required target field; decide dedup, ordering and recovery
-   ownership. A worker after translation needs a distinct local decision, obligation or effect.
+   ownership. A reaction to a capture's local fact is a separate Automation, not a
+   second job inside Translate. A worker after translation needs a distinct local decision, obligation or effect.
 8. **Specify and audit.** Work through `references/cases-to-specify.md` per declaration and hand the
    named cases to `cratis-screenplay-scenario-coverage`. Produce the audit in `references/audit-format.md`.
 
@@ -167,9 +162,16 @@ or actor that nobody confirmed. Read `references/worked-integration.md` when you
 - Clock triggers take no values (PLAY0450) and no `by` on reads (PLAY0443). `for each <View>` is
   reserved, not available.
 - Capture `when` cannot mix `and` and `or` (PLAY0089). A capture without `key` does not bind.
+- For `source events`, `key` is a required property on every `from` event (PLAY0700);
+  specs supply `given <Event>` / `when append <Event>`, not capture records (PLAY0701).
+- First sight is `added` only. Use `when added` separately for initial facts; seed
+  record updates with `given capture` of the same key. Read captures-and-reactions
+  `references/record-capture-specifications.md` for the prerequisite and child/nested rules.
 - Current V1 warns on undeclared capture/removal events (PLAY0166); V3 remains a
   separate binder check.
-- A trigger with `reads` that `produces` directly fails binding: decide in a command. `reads` never protects.
+- A trigger with `reads` that `produces` directly fails binding: decide in a command.
+  Command reads can protect with `command reads protected` and admitted shapes (v25);
+  trigger reads cannot. Stage refuses protected reads (STAGE-ESM-044); target protection remains a separate check.
 - An authorized command exercised in a spec without `given caller` is PLAY0389 at binding.
 - A list query (`=> Item[]`) binds (a snapshot list is not rendered, `STAGE-ESM-010`);
   a clock sweep that iterates items needs a code body the reference does not run

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/cases-to-specify.md

@@ -30,7 +30,9 @@ One spec in the slice does not cover the others.
 ## Translations
 | Case | Question | Typical shape |
 |---|---|---|
-| happy path | record arrives, our fact recorded | `when capture` -> `then <External>` + `then <Ours>` |
+| first sight | new record key arrives | record `when capture`, `when added` append -> `then <Fact>` and any separate Automation follow-up |
+| update | a field changes for a known key | `given capture` same key's previous record + `when capture`; field-change append holds |
+| consumed public event | capture has `source events` | `given <FromEvent>` / `when append <FromEvent>`, never capture-record fixtures (PLAY0701) |
 | arrives before our entity | the reference is unknown to us | decide: park, reject, or record an orphan fact for follow-up |
 | duplicate delivery | same record again | `given capture` (same record) + `when capture`: nothing new; or constraint rejection on our fact |
 | out of order | an older record after a newer one | `given capture` newer + `when capture` older; expected outcome stated |
@@ -66,4 +68,11 @@ One spec in the slice does not cover the others.
   tool's compiler stops before v6 does it report a false PLAY0285 on a cascade:
   then keep the cascade out of the command spec, specify it in the Automation slice
   (`when append <Trigger>`) and record the expectation. See `cratis-screenplay-scenario-coverage`.
-- `given capture` never persists between specs: state the baseline in each spec that needs it.
+- `given capture` never persists between specs: state the baseline in each record
+  update spec. First records (root, child, nested) are added only; field-change
+  `and`/`or` and transitions need previous state. Expressions/maps/unguarded record
+  appends are unchanged. See captures-and-reactions `references/record-capture-specifications.md`.
+- For `source events`, use prior typed events instead of `given capture`; cover
+  first added, per-key overlays, unchanged input, independent keys and optional
+  foreign `for` unrelated to the content key. Reference execution does not prove
+  capture redelivery deduplication or observer ordering.

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/integration-interview.md

@@ -0,0 +1,24 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Integration interview prompts
+
+Ask one group at a time, following up from the answer. Accept "unsure" as an open
+question, not an invented answer.
+
+1. **Sources.** "Which systems send us facts? For each: name, record types, channel
+   (webhook, poll, topic, file), format, who authenticates it?" Follow-up per system:
+   "Does the record carry our entity id, or do we need to remember their id against ours?"
+2. **Mapping.** "For the hardest record: does it map directly to one fact of ours, need
+   several facts, or need data we already hold?" Follow-up if not direct: "What do we
+   look up, and what happens when the record arrives before that data exists?"
+3. **Automations.** "What happens on its own after <fact>? Can it fail, wait, or need a
+   person? What do people see meanwhile? Who is allowed to do it?" Follow-up: "What
+   makes it stop? What if it ran twice?"
+4. **Recovery.** "Which records or steps can we not accept, and who fixes them, how,
+   and how does processing resume?"
+
+Skip questions already answered by the brief or model. Missing correlation is the
+most common cause of failed integrations: surface it first. Unattended work records
+assumptions as labeled open decisions in `.ai-work/screenplay/<model-slug>/STATE.md`
+and marks dependent slices open, never inventing mappings or actors.

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/public-events-and-direction.md

@@ -1,7 +1,7 @@
 <!-- Copyright (c) Cratis. All rights reserved. -->
 <!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
 
-# Public events and translation direction (released ESM v9)
+# Public events and translation direction
 
 ## Contents
 
@@ -100,26 +100,92 @@ module Integration
       direction inbound
       event ShipmentDispatched from "shipping"
         orderId OrderId
-      event OrderDispatched
+        carrier String
+      event ShipmentDelivered from "shipping"
         orderId OrderId
+        status String
+      event OrderDispatched
+        carrier String
+      event OrderDeliveryRecorded
+        carrier String
+        status String
       capture ShipmentTracking
         source events
           from ShipmentDispatched
+          from ShipmentDelivered
         key orderId
         append OrderDispatched
-          orderId = $.orderId
+          when added
+            carrier = $.carrier
+        append OrderDeliveryRecorded
+          when status
+            carrier = $.carrier
+            status = $.status
+      specification RecordingTheFirstDispatch
+        when append ShipmentDispatched
+          orderId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+        then OrderDispatched
+          for "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+      specification FoldingEarlierDispatchIntoDelivery
+        given ShipmentDispatched
+          orderId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+        when append ShipmentDelivered
+          orderId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          status = "delivered"
+        then OrderDeliveryRecorded
+          for "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+          status = "delivered"
+      specification IgnoringAnUnchangedDispatch
+        given ShipmentDispatched
+          orderId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+        when append ShipmentDispatched
+          orderId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          carrier = "DHL"
+        then no events
 ```
 
-This compiles and binds as ESM v9. Evaluating the events-source capture returns
-typed Unsupported: the event-payload-to-working-record contract is not admitted.
-Do not equate binding with a passing capture specification or invent that mapping.
-Keep correlation and resulting private events in the model and report the runtime gap.
+Requires Screenplay 4.171.0 or later (`screenplay --version`) for event-capture
+reference execution and PLAY0700/0701; older runners do not deliver these inputs
+to captures. Run `screenplay <model> --warnaserror`, then `screenplay test <model>`:
+zero diagnostics and all three capture specifications passed are the pass signals.
+
+Present the consumed public event itself: `given <Event>` / `when append <Event>`.
+Fields are typed by its local declaration. `given capture` / `when capture` is
+PLAY0701, with a repair only for exactly one `from` event (several are ambiguous).
+`for` is optional on foreign fixtures: when supplied, it is opaque nonempty text
+identifying the foreign source, not the capture key. A content key such as `orderId`
+must be required on every `from` event (PLAY0700); `$eventSourceId` and other context
+keys are refused. An empty or whitespace-only text key fails execution, even in a
+given before the action; non-text/non-numeric keys are Unsupported.
+
+Givens fold in authored order without appending. Each event overlays its top-level
+properties onto state for that typed key: absent properties retain earlier values;
+objects/lists replace whole values. First sight is `added` only, unchanged overlays
+append nothing, and field/`and`/`or`/transition guards require a modification. An
+append without `when` holds on any change, not on every delivery. Maps apply to
+before and after states; `$.field` reads the mapped merged state. An expression
+guard evaluates the after state only on a change. Root `when removed` never holds.
+
+Captures run after reactions to the same input settle; each capture append settles
+its own cascade before the next. Mixed capture/reaction assertions may need
+`then events in any order`: reference order does not prove independent observer
+order. Only `$context.occurred` (from `given clock`) is admitted; other context
+members fail binding. `children`/`nested` over events remain Unsupported, as do
+composite/list values used as scalars or watched by guards. Reference state never
+persists between specifications and does not prove redelivery deduplication,
+source acknowledgement, retry safety or context propagation. A passing reference
+scenario is not renderer admission; Stage must refuse forms Chronicle cannot realize.
 
 ## Admission and evidence
 
-ESM v9 shipped and is selected only by use of public events,
-origins, direction, event-target builders or events-source captures. At 4.135.0,
-publication reference scenarios execute; imported shapes still refuse binding.
+ESM v9 is selected by use of public events, origins, direction, event-target
+builders or events-source captures. Publication and admitted event-capture
+reference scenarios execute; imported shapes still refuse binding.
 Stage 4.52.0 (previous CLI 3.46.1, history) audited only through v7. The CLI/Stage pair (toolchain `references/renderable-subset.md`)
 reaches construct admission through its bundled ceiling but still refuses publication (STAGE-ESM-032), foreign
 events/events-source captures (STAGE-ESM-033); source admission is not rendering.

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`.