@cratis/pi 7.66.0 → 7.68.0

package/package/corpus/skills/cratis-screenplay-read-surface/references/named-keys.md

@@ -39,72 +39,188 @@ Chronicle's object keys are not ordered, encoded event stream ids.
 Choose a composite key when independent coordinates identify the business view,
 such as resource and reporting period. Prefer the natural single id when the view
 is one entity's state. Do not concatenate parts into an invented string id merely
-to pass binding; keep the truthful model and report the capability gap. Read-model
-keys do not supply projection routes: align each PDL `from ... key` mapping with
-the declared view identity (projection keys are a separate contract).
+to pass binding; keep the truthful model. Read-model keys do not supply projection
+routes: align each PDL `from ... key` block with the declared parts (several flat
+parts take an untyped `key` block naming every one; a single key of composite type
+is a different shape, and one read model has exactly one of them).
 
 ## Supply every part
 
-A scalar query keeps `by name Type` on its own body line. A composite query has a
-bare `by` header and at least two distinct `name Type [from source]` children.
-Do not combine scalar and block forms. A single-instance lookup must supply every
-key part exactly once, with the declared types; collection queries may narrow by
-a subset but still have their separate executable-query limitations.
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`) to bind a read model with
+two or more `key` marks; older binders refuse it with PLAY0268. A model with one `key`
+mark keeps its earlier ESM version and bytes, so only models that use several parts
+select v27.
+
+A scalar query keeps `by name Type` on its own body line. Each lookup shape for a
+composite-keyed read model is separate:
+
+| Shape | Form | Result |
+| --- | --- | --- |
+| Optional single-instance query | bare `by` header, then every key part once as `name Type` | binds; the caller supplies every part |
+| List query | equality `filter name Type [optional]` lines (one filter per narrowed part) | binds; a row matches when every supplied filter is equal |
+| List query, one scalar `by` | `by name Type` on one line | binds as for a single key |
+| List query with a `by` block | bare `by` header over a collection | PLAY0268: use filters |
+| Non-optional single return, or a part with a `from` source | any `by` block | PLAY0268 |
+| Missing part | any single-instance lookup | PLAY0661 |
+| Unknown, optional, collection or ill-typed part; fewer than two parts | `by` block | PLAY0662 |
+
+Do not combine scalar and block `by` forms. A caller-supplied part is never a trusted
+tenant or subject: keep ownership at the runtime boundary.
+
+Each `by` part runs its concept rules at execution, like a single `by` argument. A
+specification argument that violates a rule still binds, so a Validation rejection
+can be specified.
+
+Command and trigger reads use a child `by` block of `part = source`, with required,
+noncollection sources of compatible nominal types, not literals. Neither executes
+over a composite view in the usual way:
+
+- A command `reads … by` without the application-root `command reads protected`
+  preamble is PLAY0271. With the preamble it is PLAY0781 (reason ByParts), PLAY0782
+  first when the command has no `identifier`, and PLAY0273 when the key is not an
+  input property.
+- A trigger `reads … by` binds when the reaction only invokes commands (information
+  PLAY0270); a reaction that produces events directly or runs code is PLAY0268.
 
-A command or reaction trigger read uses a child `by` block of `part = source`.
-Sources are required, noncollection property paths with compatible nominal types,
-not literals. Trigger reads map from the trigger's declared values. The historical
-single `reads View by value` form remains available for a single key.
+Screen `data ... via query ... by value`, forms and navigation remain scalar
+lookups: they cannot supply a composite single-instance key (PLAY0661). Do not
+invent UI tuple syntax.
 
-This complete authoring-only example declares all lookup parts:
+One executable example: a composite-keyed read model, a projection whose root `from`
+and `remove with` name every part in an untyped `key` block, a list query with
+equality filters, an optional single-instance query with a `by` block, and
+specifications that run.
 
 ```screenplay
-concept ResourceId : Uuid
-concept Period : String
-module Reporting
-  feature Months
+concept InvoiceId : String
+  validate
+    min 3 message "Invoice id is too short"
+concept PaymentMethod : Enum
+  card
+  cash
+
+module Billing
+  feature Payments
     slice StateView Totals
-      readmodel ResourceMonth
-        resourceId ResourceId key
-        period Period key
-        hours Decimal
-      query FindMonth => ResourceMonth optional
+      event PaymentReceived
+        invoice InvoiceId
+        method PaymentMethod
+        amount Int
+      event PaymentRemoved
+        invoice InvoiceId
+        method PaymentMethod
+      readmodel PaymentTotals
+        invoiceId InvoiceId key
+        method PaymentMethod key
+        total Int
+      query TotalsForInvoice => PaymentTotals[]
+        filter invoiceId InvoiceId
+        filter method PaymentMethod optional
+      query Total => PaymentTotals optional
         by
-          resourceId ResourceId
-          period Period
-    slice StateChange CloseMonth
-      command CloseMonth
-        resourceId ResourceId identifier
-        period Period
-        reads ResourceMonth as totals
-          by
-            resourceId = resourceId
-            period = period
-        produces event MonthClosed
-          for resourceId
-          period Period = period
+          invoiceId InvoiceId
+          method PaymentMethod
+      projection PaymentTotals => PaymentTotals
+        no automap
+        from PaymentReceived
+          key
+            invoiceId = invoice
+            method = method
+          total = amount
+        remove with PaymentRemoved
+          key
+            invoiceId = invoice
+            method = method
+      specification TwoMethodsOneInvoice
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+        when query Total
+          invoiceId = "INV-1"
+          method = "cash"
+        then result
+          total = 8
+      specification FilterOnePart
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-2"
+          method = "card"
+          total = 3
+        when query TotalsForInvoice
+          invoiceId = "INV-1"
+        then result
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+      specification RemoveOneMethod
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+        when append PaymentRemoved
+          invoice = "INV-1"
+          method = "card"
+        then no readmodel PaymentTotals for {"invoiceId":"INV-1","method":"card"}
+        then readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+      specification RecreateRemovedInstance
+        given PaymentReceived
+          invoice = "INV-1"
+          method = "card"
+          amount = 12
+        given PaymentRemoved
+          invoice = "INV-1"
+          method = "card"
+        when append PaymentReceived
+          invoice = "INV-1"
+          method = "card"
+          amount = 20
+        then readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 20
 ```
 
-Screen `data ... via query ... by value`, forms and navigation remain scalar
-lookups: they cannot supply a composite single-instance key (PLAY0661). Do not
-invent UI tuple syntax. Context-derived query parts do not become caller inputs;
-keep tenant/subject ownership at the runtime boundary, not in editable UI filters.
+Projection rules for the same shape are in the projections skill (`SKILL.md`, keys).
+Verify with `screenplay <folder> --warnaserror` (0 errors, 0 warnings) and
+`screenplay test <folder>` (all passed, none Unsupported).
 
 ## Specifications and executable boundary
 
-`given readmodel` and `then readmodel` state every key part (PLAY0351 if missing).
-A composite absence fixture uses an object with every named part. Query result
-assertions may omit keys when arguments already select the instance.
-
-Composite read-model keys, query `by` blocks and fixtures
-over those views remain authoring-only: binding reports PLAY0268 citing
-Screenplay#599 (still open). They do not reference-execute or render. This is not
-ESM v10 admission; v10 covers reaction identity, production routes and observer
-filters. Eligible command reads separately opt into v25 with `command reads protected`;
-legacy reads remain PLAY0271, and composite keys are still refused (PLAY0781 ByParts).
-See command-surface [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
-A single explicit key does bind; Stage admission still depends on the complete
-model and projection/query shape, not just the key modifier.
+`given readmodel` and `then readmodel` state every key part (PLAY0351 if missing;
+a repeated part is PLAY0519). `then no readmodel` takes an object naming every part
+(missing PLAY0661, unknown PLAY0662, repeated member PLAY0294). Parts match one by
+one, in any order; Uuid parts compare as ordinal text with no case folding. Query
+arguments supply every `by` part (single) or the filters (list); a missing, unknown
+or repeated argument is PLAY0468. A single-instance query result may omit parts the
+arguments supply; list-query result rows state every part. A stated part that
+differs from the argument makes the row fail to match at run time, not at binding.
+
+Projections on a composite-keyed read model admit only root `from` and `remove with`.
+Joins, `children`, `remove via join`, `every`, `all`, `nested`, `clear with`,
+`variant` and reducers are PLAY0268. This is not ESM v10 admission.
+
+Stage does not admit v27: it refuses the whole model with `STAGE-ESM-016`, so
+`cratis render` cannot deliver it. Verify and reference-test the model with the
+standalone compiler, then hand the delivery to gap-fill
+(`cratis-screenplay-render-and-gap-fill`) with the model as the contract.
+Eligible command reads separately opt into v25 with `command reads protected`;
+a composite lookup there is still refused (PLAY0781 ByParts). See command-surface
+[protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
 
 ## Repairs and evidence
 
@@ -116,9 +232,3 @@ model and projection/query shape, not just the key modifier.
 - Read-model property rename remains unsupported until its mapping chain can be
   preserved. Use the model-authoring proposal/preview/apply contract, not a text
   shortcut around an identity-preserving refusal.
-
-Source: Screenplay `Documentation/screenplay/{readmodels,queries,commands,reactions,specifications}.md`,
-`fixtures/named-read-model-keys.play`, and
-`Source/DotNET/Screenplay/Semantics/SemanticModelBinder.ReadModels.cs` (identity inference).
-Its authoring delivery does not include
-an executable composite-key contract.

package/package/corpus/skills/cratis-screenplay-read-surface/verification.json

@@ -3,9 +3,9 @@
   "input": "Declare a Screenplay query and the screen that binds to it.",
   "fixtures": [],
   "assertions": [
-    { "kind": "skill-contains", "value": "query FindMonth", "file": "references/named-keys.md" },
+    { "kind": "skill-contains", "value": "query Total => PaymentTotals optional", "file": "references/named-keys.md" },
     { "kind": "skill-contains", "value": "command reads only", "file": "references/named-keys.md" },
-    { "kind": "skill-contains", "value": "remain authoring-only", "file": "references/named-keys.md" },
+    { "kind": "skill-contains", "value": "Requires Screenplay 4.204.0 (ESM v27", "file": "references/named-keys.md" },
     { "kind": "play-compiles" },
     { "kind": "skill-contains", "value": "Caller-supplied equality query filters (ESM v14)", "file": "references/equality-filters.md" },
     { "kind": "skill-contains", "value": "Supplied `null` is refused", "file": "references/equality-filters.md" },

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

@@ -108,7 +108,7 @@ reaction or drop an effect to dodge rendering.
 Preserve declared `reaction batches atomic` boundaries: each trigger occurrence's
 direct productions and each selected refusal branch are separate batches, with
 invoked commands independent. Stage refuses v22 (STAGE-ESM-016) and atomic mode
-in admitted v23–v25 (STAGE-ESM-043); the declaration is not external-effect deduplication.
+in admitted v23–v26 (STAGE-ESM-043); the declaration is not external-effect deduplication.
 For described handlers, hand off only payload computation under the v23 result
 contract; Stage STAGE-IMPL-002 means no stubs, even Stub mode. Protected v25 reads
 refuse Cratis C# rendering with STAGE-ESM-044 despite version admission and need

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

@@ -31,7 +31,7 @@ ESM). Only the probe answers renderability. `PLAY0270` entries are information,
 | Class | Meaning | Typical examples (each verified in `admission.md`) | Action |
 | --- | --- | --- | --- |
 | **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`/`performer` and composite `by` remain PLAY0268; 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-read rendering (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`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v25) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
+| **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`/`performer` and a list-query `by` block remain PLAY0268; a read model with several key parts (v27) refuses `STAGE-ESM-016`; 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-read rendering (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`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v26) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
 | **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/references/scenario-examples.md

@@ -219,6 +219,6 @@ empty-list intent is a separate claim from a keyed row being absent (`view-and-s
 queries are executable too (`ListOpenInvoices` in the backing example); caller-supplied equality filters on collections bind as ESM v14.
 Pass `by` and filters in query arguments; PLAY0468 reports unknown, repeated or
 missing required arguments. Optional filters may be omitted, supplied null is refused.
-Context-sourced/single-result filters, opaque `scoped to`/`performer`, and composite
-`by` remain PLAY0268. Compiled coverage and renderer ceilings:
+Context-sourced/single-result filters, opaque `scoped to`/`performer`, and a list-query
+`by` block remain PLAY0268. Compiled coverage and renderer ceilings:
 read-surface [equality filters](../../cratis-screenplay-read-surface/references/equality-filters.md).

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

@@ -18,7 +18,7 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | `then readmodel` / `then query` (keyed `ById`, `arguments`, `result`) | yes | yes | yes |
 | `then query` on an unfiltered list or a list narrowed by one `by` key (observable too) | yes | yes: no `arguments` for an unkeyed list, one `result` per row stating the read-model identifier, no `result` = empty list | snapshot and observable lists render |
 | Collection query with caller-supplied equality `filter`, including observable | yes | yes, ESM v14: same-named scalar property/type, AND with `by`; optional omission allowed, supplied null refused; PLAY0468 checks arguments; row order does not matter | yes on supported snapshot/observable collections; DateTime/filter parameter order refuse -010; independent Stage executor still refuses filtered assertions (-010) |
-| Context `from`, single-result filters, `scoped to`, `performer` or composite `by` | yes | PLAY0268: query context, collection-only filtering, opaque scope/implementation or multipart lookup are unadmitted | no |
+| Context `from`, single-result filters, `scoped to`, `performer` or a list-query `by` block | yes | PLAY0268: query context, collection-only filtering, opaque scope/implementation or a multipart list lookup are unadmitted | no |
 | `then no readmodel <RM> for "<key>"` | yes | yes | no |
 | `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 |
@@ -34,12 +34,12 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | Refusal branches, `$refusal` | yes | ESM v19; first matching branch wins | Stage supported subset; -039 for unfaithful refusal details/trigger groups, -011 for specification limits |
 | Query `then error` | yes | ESM v18; one query/one error, no result/denial | requires target v18 admission; a v19-capable renderer does not necessarily admit v18 |
 | Composite (JSON) values in specs | yes | yes | no |
-| Same-primitive `Date`/`DateTime` comparisons in `require`, `produces when` and command or property validation rules (v26; Requires Screenplay 4.199.0; see [date comparisons](../../cratis-screenplay-command-surface/references/date-comparisons.md)) | spec them | binds and executes; a `DateTime` input without an offset is a Validation rejection | v26 STAGE-ESM-016: gap-fill |
+| Same-primitive `Date`/`DateTime` comparisons in `require`, `produces when` and command or property validation rules (v26; Requires Screenplay 4.199.0; see [date comparisons](../../cratis-screenplay-command-surface/references/date-comparisons.md)) | spec them | binds and executes; a `DateTime` input without an offset is a Validation rejection | Host/executor run it (Requires Stage 4.135.0); renderer STAGE-ESM-046: gap-fill |
 | 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, `file` constraints, query `performer`s | spec them in design | blocked: PLAY0268 at binding, no spec runs (V3 blocked) | 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–v25 STAGE-ESM-043 |
+| 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–v26 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 STAGE-ESM-044; semantic Host/executor execute admitted reads, non-Error protected requirements STAGE-ESM-045; v25 pair admitted |
 
 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-slice-design/SKILL.md

@@ -38,8 +38,7 @@ Ask the batch below only for what the request leaves open: (1) origin of each ac
 ## Procedure
 
 1. **Fix the mode** for the scope (`cratis-screenplay-modeling-lifecycle`): design, executable
-   or renderable. It decides which shapes you may use (steps 6, 9). Read the existing model
-   before adding to it.
+   or renderable. It decides which shapes you may use (steps 6, 9). Read the existing model first.
 2. **Find each event's origin.** For every event ask who or what makes it happen and through
    which path: a persona's screen `action` or form, a reaction's `invokes`, a capture. The
    origin must be **reachable** (some screen, form, reaction or integration leads to the
@@ -54,8 +53,7 @@ Ask the batch below only for what the request leaves open: (1) origin of each ac
    separate reasons change these values, then split (`references/slicing.md` *Generic edits*).
    One input per thing the caller decides or supplies; `identifier` on the property naming the
    instance (omit only for allocation); inline `produces event <Name>` (no `for`) when the command owns the event; plain `produces <Name>` needs `for <identifier>`. Trace each input
-   (`references/field-lineage.md`) and list the values each rule reads: input, state or context
-   (`references/command-inventory.md`). A conditional input is a granularity question: two
+   (`references/field-lineage.md`) and list the values each rule reads: input, state or context. A conditional input is a granularity question: two
    decisions are two commands; one decision with a dependent rule is an implication
    (`require a == false or b > c`). Never a boolean attestation input (`confirmsX == true`)
    standing in for a rule. Place each rule in its layer (`references/rule-layers.md`). A rule
@@ -89,7 +87,7 @@ Ask the batch below only for what the request leaves open: (1) origin of each ac
 6. **Design the read side** (`references/read-model-design.md`). Enumerate every screen and
    automation first: one read model per screen component or automation need; the typical
    slice is `read model -> screen -> command -> event`. Pick the builder (declarative projection first, reducer when
-   guards cannot be expressed). The query follows the business view: a list where people scan a
+   guards cannot be expressed; a lookup `by` another identity type warns `PLAY0690`). The query follows the business view: a list where people scan a
    list, a keyed lookup where they open one thing. For **executable or renderable scope**, every
    read model needs one unambiguous identity: explicit trailing `key` first. Read `references/read-model-design.md` ("Executable identity of a read model") for the fallback order, the key decision table and the Stage rule.
 
@@ -122,7 +120,7 @@ Ask the batch below only for what the request leaves open: (1) origin of each ac
 
 - At most one `identifier` per command; never on an event property or read-model property (use `key`). At most one builder per read model (`PLAY0191`). Read `references/read-model-design.md` ("Identifier and key contract") for the exact rules.
 
-- A query's `by` goes on its own body line; `from`, single-result filters, scope, performer and composite `by` remain `PLAY0268`; equality filters on collections bind as ESM v14. Read `references/read-model-design.md` ("Query binding") for the binding rules.
+- A query's `by` goes on its own body line; `from`, single-result filters, scope, performer and a list-query `by` block remain `PLAY0268`; equality filters on collections bind as ESM v14. Read `references/read-model-design.md` ("Query binding") for the binding rules.
 
 - A `unique` constraint names a property the event declares directly; the constraint name is
   its identity (renaming starts an empty index).
@@ -146,7 +144,7 @@ collections, invariants, who sees which rows); report a finding only with a doma
 
 ## Public boundaries and view identity
 
-Translate crosses an application boundary (inbound consumes foreign public events; outbound folds private facts into exactly one local public event type); commands never publish public events. Mark view identity with trailing `key`; composite view keys remain unadmitted (`PLAY0268`) - keep the true identity and report the gap. Read [references/public-boundaries-and-keys.md](references/public-boundaries-and-keys.md) when a slice crosses an application boundary or a view needs a composite identity.
+Translate crosses an application boundary (inbound consumes foreign public events; outbound folds private facts into exactly one local public event type); commands never publish public events. Mark view identity with trailing `key`; flat composite view keys bind as ESM v27 (Requires Screenplay 4.204.0) - keep the true identity. Read [references/public-boundaries-and-keys.md](references/public-boundaries-and-keys.md) when a slice crosses an application boundary or a view needs a composite identity.
 
 ## Identity-affecting edits on an existing model
 

package/package/corpus/skills/cratis-screenplay-slice-design/references/public-boundaries-and-keys.md

@@ -11,6 +11,8 @@ the slice outline and trace every exported field; read automations-and-translati
 Mark view identity with trailing `key`. Use a composite key for independent view
 coordinates (resource + period), a natural single id for one entity's state.
 Supply every named part in single-instance queries and command/trigger reads;
-see read-surface `references/named-keys.md`. Composite view keys remain
-unadmitted (PLAY0268), unlike admitted composite stream routes.
-Keep the true identity and report the gap rather than inventing a concatenated id.
+see read-surface `references/named-keys.md`. Flat composite view keys bind as ESM v27
+(older binders refuse with PLAY0268; compiler requirement in named-keys), as do composite
+stream routes. Command and trigger reads by parts stay refused, and Stage does not admit
+v27. Keep the true identity rather than inventing a concatenated id; choosing between
+shapes: streams-and-consistency `references/read-model-keys.md`.

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

@@ -130,7 +130,10 @@ Observable delivery does not make a materialized projection decision-consistent;
 decision needs a guarded read (`rule-layers.md`, `cratis-screenplay-streams-and-consistency`). Prefer a
 declarative projection (mappings, event joins, counters, bounded children, removals); a join
 consumes event facts, not another read model. Use a reducer when prior-state, attempt or
-ordering guards cannot be expressed declaratively. Review every writer of a property: AutoMap
+ordering guards cannot be expressed declaratively, and the view is only ever looked up by the
+event-source identity: a reducer cannot be re-keyed, so a query `by` another identity type warns
+`PLAY0690`; aggregate by a payload value with a projection keyed on each `from`, or a join
+(projections [reducer identity](../../cratis-screenplay-projections/references/reducer-identity.md)). Review every writer of a property: AutoMap
 can introduce updates from other events. Use variants only when lifecycle stages have different
 shapes. Keep growing histories in a separate view; never combine several people's PII under
 one read-model instance (compose queries across person-scoped views instead).
@@ -327,8 +330,9 @@ module Berths
 - A query's `by` goes on its own body line. Optional keyed and collection queries
   bind, including observable delivery. Caller-supplied equality filters on collections
   bind as ESM v14; `by` ANDs with supplied filters. `from`, single-result
-  filters, scope, performer and composite `by` remain PLAY0268 for their respective
-  context/cardinality/opaque/multipart gaps. Read read-surface
+  filters, scope, performer and a `by` block on a list query remain PLAY0268 for their
+  respective context/cardinality/opaque/multipart gaps. A composite-keyed optional
+  single-instance query takes a `by` block naming every part (ESM v27). Read read-surface
   [equality filters](../../cratis-screenplay-read-surface/references/equality-filters.md).
 
 ## Executable identity of a read model

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

@@ -175,8 +175,9 @@ Use `when append <PrivateEvent>` then `then <PublicEvent>`, not `then readmodel`
 follow-up events are exhaustive and ordered. Read
 [publication and fold cases](../cratis-screenplay-automations-and-translations/references/public-events-and-direction.md)
 when specifying outbound facts or event-source captures: it owns the minimum
-compiler, PLAY0700/0701, key folding and Unsupported boundaries. Composite view
-fixtures remain unadmitted; see read-surface `references/named-keys.md`.
+compiler, PLAY0700/0701, key folding and Unsupported boundaries. Composite-keyed
+view fixtures state every key part (Requires Screenplay 4.204.0, ESM v27); see
+`references/vocabulary.md` and read-surface `references/named-keys.md`.
 
 ## Reusable fixtures, routes and recovery intent
 

package/package/corpus/skills/cratis-screenplay-specifications/references/query-rejections.md

@@ -10,6 +10,10 @@ through their concept's `validate` rules in every ESM version. An omitted option
 filter is not validated. A violation is a Validation rejection carrying the rule's
 message; a valid key with no matching instance is absence.
 
+On a composite-keyed read model every `by` part of a single-instance query is validated
+the same way; an argument that breaks a part's concept rule binds and rejects with
+Validation (Requires Screenplay 4.204.0, ESM v27).
+
 Use exactly one query request and one `then error`, bare or with a message. No
 command/append/reaction action, result, `then no result` or `then denied` may
 accompany it (PLAY0465). An actionless `then query` with `arguments` and no `result`

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

@@ -35,6 +35,23 @@ This reference holds the given/when/then construct table and the enumeration and
 | `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}]` |
 
+## Composite-keyed read models
+
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`); older binders refuse a
+read model with two or more `key` marks, and every specification over it, with PLAY0268.
+
+- `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,
+  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).
+- A single-instance `then result` may omit parts the arguments supply; list rows state
+  every part. A stated part that disagrees with the argument fails to match at run time.
+- Parts match one by one in any order; Uuid parts compare as ordinal text.
+
+The complete model with these specifications is in read-surface `references/named-keys.md`.
+
 ## Parse and binding diagnostics
 
 PLAY0358 is a syntax error; PLAY0388 also occurs at parse time for extra text

package/package/corpus/skills/cratis-screenplay-streams-and-consistency/SKILL.md

@@ -138,6 +138,8 @@ Requires Chronicle 19.59.6 or later (19.59.3 for the InMemory provider) for the
 
 **Modeling defaults** (deviate with a recorded reason)
 - One business identity per stream; cross-stream references are payload properties.
+- A read model's key is not a stream identity. Read [references/read-model-keys.md](references/read-model-keys.md)
+  when choosing one id, flat composite key parts (v27) or a composite-typed key.
 - Copy the source id into the payload only when a consumer needs it as a value.
 - Give each invariant an authoritative atomic decision point and inspect every path that could
   violate it. A constraint violation rejects that command's whole append set; a reaction cascade
@@ -145,7 +147,7 @@ Requires Chronicle 19.59.6 or later (19.59.3 for the InMemory provider) for the
 - New models declare `reaction batches atomic`: direct productions per trigger
   occurrence and each selected refusal branch are separate batches; invoked commands
   stay independent. Legacy absence retains per-fact appends. Stage refuses v22
-  with STAGE-ESM-016 and atomic mode in admitted v23–v25 with STAGE-ESM-043. Read
+  with STAGE-ESM-016 and atomic mode in admitted v23–v26 with STAGE-ESM-043. Read
   [atomic boundaries](../cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md)
   when defining failure rollback; batching is not redelivery deduplication.
 - Match duplicate protection to scope. A property constraint lets a source re-claim its own

package/package/corpus/skills/cratis-screenplay-streams-and-consistency/references/read-model-keys.md

@@ -0,0 +1,46 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Read-model keys: one id, flat parts or a composite-typed key
+
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`) for a read model with two or
+more `key` marks; older binders refuse it with PLAY0268. A read model with one `key` mark
+keeps its earlier version and bytes.
+
+A read model's key says which instance a lookup or projection reaches. It is not a stream
+identity and not an atomic decision point: choose it after the streams, and keep invariants
+in constraints and commands.
+
+## Choose the shape
+
+| Business shape | Key | Why |
+| --- | --- | --- |
+| The view is one entity's state | One natural `key` property (default) | Binds on every supported version, and the event source usually supplies it |
+| Independent coordinates identify the view (resource and period, plant and field), read by filtering on some parts or by all parts | Several flat `key` properties (v27) | Each part keeps its name and type; a list narrows by any part with equality filters |
+| One value object already identifies the entity everywhere (it is also a command or event value) | One `key` property whose type is a composite `type` | Executes on earlier versions; projections use a typed `key TypeName` block |
+
+A read model has exactly one of the two composite shapes: mixing flat parts with a
+composite-typed key is PLAY0660, though one application may hold read models of both.
+Do not concatenate parts into a string id to avoid a composite key, and do not invent a
+composite type only to carry flat parts: both hide the identity the model should state.
+
+## What flat parts do and do not do
+
+- **Equality is per part**, in any order. Uuid parts compare as ordinal text with no case
+  folding, so write one spelling of each uuid in events, fixtures and query arguments.
+- **A projection names every part** in an untyped `key` block on each root `from` and
+  `remove with`. The parts come from the event payload; they need not match the event
+  source. `remove with` deletes one instance and a later `from` recreates it.
+- **A composite key does not enforce uniqueness.** Two events can still claim the same
+  part values; use a `unique` constraint over the same properties when the store must
+  refuse the duplicate (`references/consistency-and-concurrency.md`).
+- **Lookups.** An optional single-instance query names every part in a `by` block; a list
+  uses equality filters. A command or reaction that must read the view by parts is refused
+  (PLAY0271, PLAY0781 ByParts, or PLAY0268 for a producing reaction), so decide on a stream
+  the command owns instead, or restructure the read. Do not drop the read to bind.
+- **Limits.** Joins, `children`, `nested`, `every`, `all`, `variant` and reducers on the
+  composite-keyed view are PLAY0268. Stage refuses v27 with STAGE-ESM-016, so deliver it
+  through gap-fill with the model as the contract.
+
+Read read-surface `references/named-keys.md` for one complete executable example and the
+projections skill `references/pdl-grammar.md` for the key block syntax.

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

@@ -39,6 +39,10 @@ superseded statement needs context; exceptions do not change the contract.
 2. **Check the folder, warnings as errors.** `screenplay <folder> --warnaserror` or
    `cratis screenplay validate <folder> --warnings-as-errors`. Warnings hide defects:
    PLAY0029 (a misspelt keyword or a `type` inside a slice) drops a construct silently.
+   A committed `screenplay.json` at the model root declares the repository's gate (checks, warnings
+   as errors, scope, open questions): run without repeating those flags (confirm with
+   `--print-gate` before dropping `--warnaserror`), read it with
+   `--print-gate`, and treat a refused file as "could not run" (`references/verdicts.md`).
 3. **Pick the compiler deliberately and name it.** Standalone `screenplay` for
    language checks and reference specifications; `cratis` for rendering
    and generation. Report both tool and version, rather than transferring a verdict across
@@ -63,6 +67,7 @@ superseded statement needs context; exceptions do not change the contract.
 | --- | --- | --- |
 | Check root | `screenplay <root> --warnaserror --no-color` | `cratis screenplay validate <root> --warnings-as-errors -o json-compact` |
 | Scope/checks | `--scope <address>`, `--check <names>`; a scoped pass is not whole-application success | `validate --executable` (bundled binder, no write), `--check <names>`, `--scope`; `render --scope`/`--check`; `cratis screenplay conform` |
+| Declared gate | `screenplay <root> --print-gate`, `--format json`, `--no-gate-file` | `validate <root> --print-gate`, `--no-gate-file`; the same `screenplay.json` |
 | Reference execution | `screenplay test <root>` or MCP `run-specifications` | Discover bundled MCP capability; target tests are not V4 |
 | MCP | `screenplay mcp <root>`; discover schemas | `cratis screenplay mcp [root]`; registered by `cratis ai install` |
 | Render boundary | Binder admission is not Stage admission | The CLI renders only ESM versions it knows; a newer bound model gets `CLI-RENDER-004` |
@@ -101,7 +106,7 @@ changes with the root folder name.
 - **Executable** (binds, V3): `references/executable-subset.md`. Optional keyed lookups, unfiltered
   lists and lists narrowed by one `by` key (observable too) bind; caller-supplied equality
   filters on collections bind as ESM v14. Context `from`, single-result
-  filters, opaque `scoped to`/`performer` and composite `by` remain PLAY0268. Read
+  filters, opaque `scoped to`/`performer` and a `by` block on a list query remain PLAY0268. 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 handlers remain PLAY0268.
@@ -120,9 +125,10 @@ changes with the root folder name.
 - **Public contracts and routes (v9/v10/v11):** public contracts and direction select v9;
   reaction identity, production overrides and observer filters select v10;
   qualifying retained non-route Double literals select v11.
-  Composite view keys remain authoring-only (PLAY0268), while one explicit
-  `key` binds. Read `references/production-routes-and-filters.md` and read-surface
-  `references/named-keys.md`.
+  Flat composite read-model keys select v27 (Requires Screenplay 4.204.0; older binders
+  report PLAY0268); one explicit `key` keeps its earlier version. Read
+  `references/production-routes-and-filters.md`, [language admission](references/language-admission.md)
+  and read-surface `references/named-keys.md`.
 - **Enum numbers (v12):** read command-surface `references/enum-numbers.md` for
   pins, stored numbers and Stage output; `references/diagnostics.md` owns PLAY0667–0671.
 - **Concept strategies (v15):** read
@@ -189,7 +195,7 @@ Read [references/diagnostics.md](references/diagnostics.md) when a PLAY, STAGE o
 7. Mark read-model identity with trailing `key`, not `identifier`. Otherwise single-instance
    queries must agree on `by`; only with none and an admitted list query can `*Id`
    inference run. Queryless views need `key` (read-surface `references/named-keys.md`).
-   Align projection keys. Multipart keys remain PLAY0268.
+   Align projection keys; several parts need an untyped `key` block (v27).
 8. Projection `key` routes only on `from`; joins never create; `all` is per source.
 9. `null` only for optional read-model properties in specifications.
 10. `then` events are exhaustive and ordered; after `when append` they list only what followed.