@cratis/pi 7.62.0 → 7.63.0

package/package/corpus/skills/cratis-screenplay-toolchain/references/diagnostics.md

@@ -14,6 +14,7 @@
 - Structural completeness and timeline checks
 - Editor versus C# verdicts
 - Consistency errors (V1: the model contradicts itself)
+- Batches, described handlers, text rules and protected reads
 - Binding (V2 and V3) - see `executable-subset.md` for the full table
 - Frequent errors
 - Render admission (V5): `STAGE-*`, `CLI-RENDER-*`, `STAGE-CRATIS-*`
@@ -55,7 +56,7 @@ Legacy compliance spellings (`@pii`/`@sensitive`) do not evade PLAY0515.
 
 ## Public events and translation direction
 
-All are errors. These constructs bind as ESM v9, except public/foreign imports without local shapes (PLAY0268).
+PLAY0607–0620 are errors. These constructs bind as ESM v9, except public/foreign imports without local shapes (PLAY0268).
 
 | Code | Meaning / fix |
 | --- | --- |
@@ -80,6 +81,18 @@ or non-Translate direction. Repair discovery uses `repair-capabilities`, workspa
 `repairs`, then revision-checked `propose-repair`; do not guess a direction.
 See automations-and-translations `references/public-events-and-direction.md`.
 
+| Code | Severity | Meaning / fix |
+| --- | --- | --- |
+| PLAY0694 | W | An unrouted reaction in a directionless Translate consumes an event its own capture appends (root, children or nested). Keep the capture here and move the reaction to a separate Automation slice with its specs. No automatic repair; `--warnaserror` fails. Other slices' captures and reactions with a `from` route do not trigger this check; explicit inbound local-event consumption is PLAY0616. |
+| PLAY0700 | E | Event-capture `key` is not required on every `from` event, or uses a `$` context key. Choose a required content property or deliberately change the source contracts; no repair. |
+| PLAY0701 | E | `given capture` / `when capture` names a capture over events. Present `given <FromEvent>` / `when append <FromEvent>`. A compiler-authored repair exists only for exactly one `from` event; several are ambiguous. Review the specification repair individually; no fix-all or pinned evidence. |
+
+Requires Screenplay 4.171.0 or later (`screenplay --version`) for PLAY0700/0701
+and event delivery to captures; older runners do not execute that delivery.
+Requires Screenplay 4.176.0 or later for PLAY0694; older compilers leave the
+legacy directionless co-location unchecked. Full capture execution and ordering:
+automations-and-translations `references/public-events-and-direction.md`.
+
 ## Explicit enum member numbers
 
 Source errors; the pins bind as ESM v12:
@@ -290,12 +303,43 @@ or V4 execution. Run the CLI or MCP for those verdicts.
 | PLAY0287 | producer/capture/spec assigns a field the event lacks |
 | PLAY0291-0294 | bad single-line JSON / unknown key / wrong shape / duplicate key |
 
+## Batches, described handlers, text rules and protected reads
+
+Use code and typed subjects from [diagnostic arguments](diagnostic-arguments.md), not
+message parsing, for codes that declare arguments. Other messages still explain
+refusal reasons. Read [language admission](language-admission.md) before changing modes.
+
+| Code | Meaning / fix |
+| --- | --- |
+| PLAY0693 | Duplicate/conflicting/invalid atomic batch declaration; keep one application-root declaration, do not remove intended atomicity |
+| PLAY0695 (I) | Described handler admitted; a target must supply its payload body |
+| PLAY0696 | Pending handler without productions, including response-only; declare unconditional productions |
+| PLAY0697 | Conditional productions under pending intent; result v1 needs unconditional events |
+| PLAY0698 | Pending intent plus another handler; retain one |
+| PLAY0699 | Pattern outside portable dialect or over 1,000 UTF-16 units / 3,000 expanded nodes; rewrite the refused construct |
+| PLAY0780 | Invalid placement/repetition of `command reads protected`; declare once at root |
+| PLAY0781 | Protected read shape/key refused; inspect the closed reason, never downgrade to an unguarded read |
+| PLAY0782 | Omitted `by` without command identifier; declare the lookup input |
+| PLAY0783 | Command combines reads and concurrency; choose the intended boundary |
+| PLAY0784 | Unknown read/property path; reference a declared read or alias |
+| PLAY0785 | Ambiguous view path; use distinct aliases on repeated reads |
+| PLAY0786 (I) | Eligible legacy model; preview typed preamble repair, individually review absence/conflict semantics |
+| PLAY0787 (W) | Exact deprecated Studio text-rule pattern; repair to literal rule or equality, preserving message/severity |
+| STAGE-ESM-043 | Atomic mode not realized, even in admitted v23–v25; retain declaration and gap-fill |
+| STAGE-ESM-044 | Protected reads not realized despite v25 version admission; keep protection and gap-fill |
+| STAGE-IMPL-002 | Described handler body not realized by Stage, even Stub mode; no stubs emitted |
+
+Invalid match syntax remains PLAY0367. Property/concept text rules bind v24;
+`contains`/`starts with` in conditions only still fail PLAY0268. Stage rejects
+v22/v26 and mixed pairs with STAGE-ESM-016; v23–v25 admission does not implement
+bodies, batches or protected reads (STAGE-ESM-044).
+
 ## Binding (V2 and V3) - see `executable-subset.md` for the full table
 | Code | Meaning | Fix |
 |---|---|---|
-| PLAY0268 | construct the ESM cannot represent; read the message for the construct (`executable-subset.md` lists the common ones: handler, list or observable query, `pii`, `produces when` over read models, v6 constructs on an older bundled compiler) | stay in design mode, or change the construct if the domain allows; never strip `pii`/authorization |
+| PLAY0268 | construct the ESM cannot represent; read the message for the construct (`executable-subset.md` lists attached handlers, unsupported query shapes, protected enum/identity concepts, read paths without opt-in or in conditions, and older bundled-compiler limits) | stay in design mode, or change the construct if the domain allows; never strip `pii`/authorization |
 | PLAY0269 / 0270 | UI deferred / authoring metadata (I) | none |
-| PLAY0271 | legacy `reads` or a `concurrency` block keeps its legacy meaning and cannot bind (error) | design gap; a constraint for uniqueness; protected decisions are a target requirement |
+| PLAY0271 | legacy `reads` or a `concurrency` block keeps its legacy meaning and cannot bind (error) | opt eligible command reads into v25 with reviewed preamble repair; `concurrency` remains unbound; uniqueness uses a constraint, target realization stays separate |
 | PLAY0273 | incoherent: ambiguous `for`, property not on event revision, operand type mismatch, derived `$eventContext` path | fix the reference |
 | PLAY0350 | `null` in command/event value | Chronicle semantics (nullable event properties are CHR0012; an optional fact is a separate event), not only a binder limitation: specs cannot state an absent command/event value. Omit the value or record a capability gap; whether the optional detail is really a separate fact is a review question, not this code's fix |
 | PLAY0351 | given/then readmodel lacks the key property | add the keyed query's `by` property |
@@ -336,10 +380,26 @@ or V4 execution. Run the CLI or MCP for those verdicts.
 | PLAY0683/0684 | PLAY0683: generated non-identifier below 64 random bits warns (a single-property unique constraint suppresses it); PLAY0684: generated identifier below 64 random bits is an error |
 | PLAY0687 | capture `source events` spans multiple origins; split into one capture per origin (event store) |
 | PLAY0688 | generated strategy refutes a concept rule; read its violating example, align the rule/strategy or review the derived-`matches` repair |
-| PLAY0689 (W) | generated-concept rule proof is undecided; reason names regex fragment/budget/opaque limits. Never treat a warning as proof |
+| PLAY0689 (W) | generated-concept rule proof is undecided; reason names regex fragment/budget/opaque limits or ambiguity. Only deterministic matches patterns prove containment; passing samples prove nothing |
+| PLAY0691 | finite pattern support cannot be counted within the generation budget; simplify the strategy, never treat it as an Unproven rule warning or redraw |
+| PLAY0692 | pattern support is empty for some valid UTC date in the compiler's next-100-year horizon; repair the pattern/checksum contract, never sample around it |
 | PLAY0685 | own response name used under execute failure; outer successful responses remain available. UI composition `references/response-continuations.md` |
 | PLAY0289 | (binding) no documents: empty root |
 
+Requires Screenplay 4.164.0 (`screenplay --version`) for PLAY0688/0689 (ESM v20),
+4.172.0 for finite generation PLAY0691/0692 and checksum validation (v21); older
+compilers refuse those constructs with PLAY0268. A refuted rule's PLAY0688 repair
+uses the strategy-derived matches pattern (and declared checksum validation if
+absent). Inspect MCP `rules[]` for status/witness/reason and only use a repair
+when diagnosticCode/repair is reported. Pattern/random/rule no longer refuse
+PLAY0268; generated secrets still do. Requires Stage 4.109.0 for v20, 4.115.0
+for v21 admission/all-Proven unpinned specs, 4.117.0 for warning/info rules,
+4.118.0 for checksum validation and 4.119.0 for pattern/random. Older renderers
+refuse those constructs or require pins even for Proven rules. Bad pins fail
+STAGE-ESM-011; unpinned Unproven/Refuted rules fail -038; opaque rules fail -005
+before pin evaluation. `generate rule` remains -028; checksum remains -042 only
+on legacy syntax paths. Tool-author checks: [generation checks](generation-checks.md).
+
 Fix order: E at V1 -> W at V1 -> silent-gap check -> V2 codes (if the mode needs V3).
 Report each as `code file:line one-line meaning`; never paste more than about 30 lines.
 
@@ -358,7 +418,7 @@ Publication STAGE-ESM-032, foreign facts/event captures 033, claim-reading/opaqu
 | STAGE-ESM-004 / 006 / 013 | a `StateChange` without commands; `produces` that cannot render (expression/enum conditions, literal or computed mappings, duplicate tags); event-context value other than `$context.occurred` (reactions: `$context.causedBy.*`, `$context.eventSourceId`) |
 | STAGE-ESM-005 / 015 | code rule or code validation bodies; authorization Stage cannot render exactly (role-claim URIs, nested or unresolved opaque policies, opaque-policy subjects that are not text, Uuid, Date or DateTime). Role-only, authenticated, opaque pure policies and Uuid/Date/DateTime/text claim targets render |
 | STAGE-ESM-007 / 009 / 010 / 017 | projection shape (one projection or reducer per read model, affected-instance key, unsupported query shapes, keys, unsupported `all` mappings, event-context values) |
-| STAGE-ESM-011 | specification shape not rendered (`when append` outside the single-hop reaction subset, command specifications that cascade into reactions, composite values, an unauthenticated caller carrying roles or claims, v15 fixtures that do not match their strategy). Command scenarios and single-hop reaction appends render |
+| STAGE-ESM-011 | specification shape not rendered (`when append` outside the single-hop reaction subset, command specifications that cascade into reactions, composite values, an unauthenticated caller carrying roles or claims, generated fixtures that do not match their strategy shape or concept rules). Command scenarios and single-hop reaction appends render |
 | STAGE-ESM-014 | constraint shape (multi-claim in one command, optional or composite targets) |
 | STAGE-ESM-019/022 | reducer or opaque pure policy body outside the pure allowlist |
 | STAGE-ESM-024 | interval, schedule, application, startup and shutdown triggers, opaque reaction bodies, captures, Translate, clock/trigger/capture specifications |

package/package/corpus/skills/cratis-screenplay-toolchain/references/executable-subset.md

@@ -24,7 +24,8 @@ non-route Double literals (exact lowering of Double-mode literals) as v11, non-p
 numbers as v12, concept compliance as v13, caller-supplied collection equality filters as v14,
 concept generation strategies and freshness as v15, stored event names as v16,
 no-event assertions/redelivery as v17, query-error specifications as v18,
-invocation refusal branches as v19 and generated-concept rules as v20. Always name
+invocation refusal branches as v19, generated-concept rules as v20, and finite
+pattern/random/rule generation plus checksum validation as v21. Always name
 the tool with a V2 or V3 result. When tool and documentation disagree, the tool decides
 current capability; the documentation and the domain decide intended correctness. Record
 the gap, never strip the model to pass. Use the actual binder before promoting an older
@@ -38,6 +39,10 @@ never bind (`verdicts.md`).
 Complete examples that bind live in `executable-example.md`, `pdl-example.md` (projections),
 `automation-translate-example.md` (ESM v6) and `generated-responses-example.md` (ESM v7).
 
+For atomic batches (v22), described handlers (v23), ordinal text rules (v24) and
+protected reads (v25), read [language admission](language-admission.md). A later
+version alone does not enable either application opt-in.
+
 ## Caller and compliance boundary
 
 `$identity.id`/`.name`/`.userName` are aliases of the admitted
@@ -168,11 +173,14 @@ fixtures and `then returns`. Unsupported generated types (`-028`) and result com
 `references/generated-values-and-responses.md`.
 Complete examples: `generated-responses-example.md`, `generation-strategies-example.md`.
 
-- A generated property is command-only, required, scalar and a generatable concept backed by Uuid or String;
-  bare primitives, optional and collection types are invalid. Uuid has implicit `uuid`; String needs a strategy.
+- A generated property is command-only, required, scalar and a generatable concept backed by Uuid/String,
+  or Int with `random` (v21). Bare primitives, optional and collection types are invalid.
+  Uuid has implicit `uuid`; String needs a strategy. Generated identifiers remain Uuid/String only.
   Explicit serialized generation selects v15, with strict fixture encoding and whole-source freshness for all
-  generated destinations. `pattern`, `random`, `rule`, `sequence` and generated secrets remain unadmitted;
-  generated-concept rules bind as v20 with proof diagnostics PLAY0688/0689.
+  generated destinations. Sequence and generated secrets remain refused.
+  Generated-concept rules bind as v20 with proof diagnostics PLAY0688/0689;
+  pattern/random/rule and checksum validation bind as v21. PLAY0691 is uncountable
+  support within budget; PLAY0692 is empty support on a scanned UTC date.
   See command-surface `references/generated-values-and-responses.md` and `generation-strategies-example.md`. Modifier order is `Type optional generated identifier`.
 - Generated values are not request inputs, form fields, invocation arguments or ordinary `when` values. Generation
   runs after authorization and validation and before productions, so a denial or a validation failure never
@@ -180,7 +188,10 @@ Complete examples: `generated-responses-example.md`, `generation-strategies-exam
 - A policy (including inherited or composed ones and the implicit `subject` of a generated identifier), a property
   rule or a requirement that references a generated value reports `PLAY0273`; reference input properties only. A
   generated property whose concept declares rules selects v20; refuted rules report
-  PLAY0688 and unproven rules warn PLAY0689. Opaque execution needs a target.
+  PLAY0688 with a witness and Unproven rules warn PLAY0689 with a reason. Proven
+  rules bind silently; matches containment requires deterministic patterns, not
+  passing samples. Opaque validation needs a target. Opaque generation rules use
+  pinned String results without executing their bodies.
   A reaction mapping into a generated property is invalid.
 - Responses: `returns <property>` is scalar; bare `returns` opens an ordered record of `<name> [<Type>] = <property>` fields
   over direct properties of the same command (collections, read aliases, arithmetic and whole read models are not
@@ -198,14 +209,25 @@ Complete examples: `generated-responses-example.md`, `generation-strategies-exam
 - A reaction-invoked command that reaches generation is `Unsupported(IdentityAllocation)`; response-only commands run
   and discard the response. Generated values give no idempotency, retry or deduplication guarantee.
 
-Requires Screenplay 4.68.0 or later (`screenplay --version`) for generated values and responses (ESM v7), and 4.147.0 or later for concept generation strategies and freshness (ESM v15); older compilers refuse them with PLAY0268.
+Requires Screenplay 4.68.0 or later (`screenplay --version`) for generated values and responses (ESM v7), 4.147.0 for strategies/freshness (v15), 4.164.0 for generated-concept rules (v20), and 4.172.0 for pattern/random/rule/checksum (v21); older compilers refuse the respective constructs with PLAY0268.
+
+Pins satisfy both strategy shape and concept rules; failure is Rejected(Contract),
+not an input error or redraw. Pin date segments with `given clock`; without it the
+runner checks digit widths only. Generation checksum does not add validation:
+author `validate checksum` for arithmetic. Requires Stage 4.109.0 for v20,
+4.115.0 for v21 admission/all-Proven unpinned specs, 4.117.0 for warning/info rules,
+4.118.0 for checksum validation and 4.119.0 for pattern/random rendering; older
+renderers refuse those constructs or require rule-bearing pins even when Proven.
+Unproven/Refuted rules still need pins (-038), bad pins fail -011, and
+`generate rule` remains -028. Do not remove rules or classification to render.
 
 ## Released public boundaries and observer routes
 
 Public/origin events, explicit Translate direction, event-target builders and
-`source events` captures bind as ESM v9. Publication folds execute;
-source-event captures and reached opaque event-target reducers return typed
-Unsupported. Public/foreign imports still lack a local shape and refuse PLAY0268.
+`source events` captures bind as ESM v9. Publication folds execute, and so do
+captures over events (Requires Screenplay 4.171.0; a specification presents the
+consumed event with `given <Event>` / `when append <Event>`); reached opaque
+event-target reducers return typed Unsupported. Public/foreign imports still lack a local shape and refuse PLAY0268.
 See automations-and-translations `references/public-events-and-direction.md`.
 Production overrides and reaction/reducer filters bind and select v10;
 filters match routed source/stream names only. Read
@@ -231,9 +253,15 @@ Requires Screenplay 4.117.0 or later (`screenplay --version`) for ESM v9, 4.129.
 
 ## Code attachments (what binds, what never does)
 
+Pending `handler implementation` beside unconditional `produces` binds as a described
+command (v23). Its payload-only body returns Unsupported ImplementationBody when reached;
+denial/validation specs still run. Read [language admission](language-admission.md) for
+v22–v25 and [described handlers](../../cratis-screenplay-command-surface/references/described-handlers.md)
+for the result contract. Attached handlers remain unbound.
+
 Inline fences (`csharp`, `typescript`, `react`, `html`, `sql`) and `file <path>` attach
 code to an owner. Three kinds block binding (PLAY0268, V3 blocked, no specification runs):
-the command `handler`, the `file` constraint (see below) and a query `performer`
+the attached command `handler`, the `file` constraint (see below) and a query `performer`
 ("uses delivery, filtering, scope, or implementation behavior outside the first ESM v1
 vertical"). Everything else binds as an **opaque requirement** that needs a target to
 execute: reducer transitions, rule predicates, command and concept code validation, policy
@@ -246,22 +274,22 @@ bodies still leave their owner non-executable.
   can only declare uniqueness: declare it with `unique ...`, and put other rules in command
   validation or a `require` condition.
 
-- A command `handler` **never binds**: PLAY0268 "Command '<n>' handler requires a
-  constrained implementation attachment." This holds with a `file`, with a fence, and with
-  `implementation` or `hint` (including a pending intent with no payload). On a handler,
-  `implementation` and `hint` are authoring intent: no execution, lock or confirmation.
+- A file/fenced command `handler` remains PLAY0268, wrapped or direct. A pending
+  intent instead selects v23 with unconditional productions (PLAY0695 information).
+  Missing productions use PLAY0696, conditional ones PLAY0697, duplicate handlers PLAY0698.
+  Hints are not executable code, locks or confirmation.
 - A command property named rule also accepts an `implementation` block (ordered
   `hint` lines, at most one `file` or tagged fence). With a source attached it binds like a
   direct source; hints-only or empty is pending intent: valid source, PLAY0268 at binding.
   The block is rejected on concept rules, built-in property rules and whole-command
   `require`/`validate` bodies.
-- A handler therefore makes the slice non-executable and non-renderable: it is gap-fill
-  with the model as the contract.
+- A reached described body is Unsupported, not a passing specification; Stage refuses
+  it with STAGE-IMPL-002, even in Stub mode. Deliver its body as authorized gap-fill.
 - Stage admits only pure reducer bodies (Roslyn allowlist, STAGE-ESM-019 and 022);
   code validation is refused (STAGE-ESM-005). Opaque pure policies render.
 - The reference runner returns Unsupported for the opaque bodies that do bind (rule and
   policy predicates, code validation, reducer transitions); a specification that needs one
-  never passes. Handlers, file constraints and query performers (and reaction effects on a trigger with
+  never passes. Attached handlers, file constraints and query performers (and reaction effects on a trigger with
   `reads`) are different: they leave the whole model unbound, so no specification runs at
   all.
 
@@ -274,13 +302,13 @@ bodies still leave their owner non-executable.
 | `pii` or `secret` on a concept | PLAY0268 | Older compilers refuse it outright. Current compilers admit v13 except enum/identity compliance and events mixing personal or explicitly subject-scoped secret values with explicit subject marks; see `compliance.md` in command-surface references |
 | `query` with a composite `by` block, or `by ... from` context-derived arguments | PLAY0268 | composite `by` blocks remain unadmitted. An optional scalar snapshot lookup, an unfiltered list (`RM[]`) and a list narrowed by one caller-supplied `by` key bind, in their `observable` form too |
 | Context `from`, single-result filters, `scoped to`, `performer` queries | PLAY0268 | Typed query context, filtering of single results, opaque scope and query implementation remain unadmitted; each refusal names its reason. Caller-supplied collection equality filters bind as v14. `observable` goes in the return position (`=> observable RM[]`); as a body line it is PLAY0048 |
-| `contains` or `starts with` in conditions | PLAY0268 | equality and numeric ordering only |
+| `contains` or `starts with` in conditions only | PLAY0268 | `require`/`produces when` conditions admit equality and numeric ordering only; property/concept text rules bind as v24 |
 | Date or DateTime comparison, `today` | PLAY0268 | no runtime date value |
 | Rule on a nested path (`lines.qty all > 0`) | PLAY0268 | put the rule on the nested value's concept |
-| `require` or `produces when` over a read-model path | PLAY0268 | needs decision-consistent reads |
-| `reads <View> ...` on a command | PLAY0271 (error) | legacy, cannot imply decision consistency |
+| Read paths without protected opt-in, or in `produces when` | PLAY0268 | v25 admits single-level paths only in `require` and produced-event mappings |
+| Legacy `reads <View> ...` on a command | PLAY0271 (error) | `command reads protected` opts eligible views into v25; see command-surface protected reads |
 | `concurrency` block on a command | PLAY0271 (error) | "concurrency metadata keeps its legacy meaning and cannot bind to ESM v1" |
-| `handler` (see above) | PLAY0268 | gap-fill |
+| File/inline `handler` (see above) | PLAY0268 | pending described handlers instead bind v23; body execution and rendering remain gaps |
 | `$context.tenant`, roles, claims, causation | PLAY0268 | no portable scalar counterpart |
 | Arithmetic or raw expression in a `produces` mapping | PLAY0268 | |
 | Template `` `${x}` `` or `$causedBy` in a projection | PLAY0268 | |

package/package/corpus/skills/cratis-screenplay-toolchain/references/generation-checks.md

@@ -0,0 +1,93 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Generation checks for tool and renderer authors
+
+Use the language-owned APIs instead of copying option tables, rule evaluators or
+proof logic. These are .NET APIs of Screenplay, not Cratis C# target contracts.
+They never generate a value or execute an attached body.
+
+## Choose the check
+
+| Need | API | Result and boundary |
+| --- | --- | --- |
+| Populate strategy/option controls | `GenerationStrategyCatalog.All`, `Find(string name)` in `Cratis.Screenplay.Semantics` | Exact case-sensitive source spelling; unknown names return null. Descriptors expose ESM kind, source primitives, introducing version, admission/executability, fixed bits and options with placement, kinds, bounds, choices, defaults and conditions. `rule` serializes as `implementation`; reserved `sequence` is not admitted. Metadata alone is not validation. |
+| Check one concept declaration | `SemanticConceptCheck.Check(concept, utcAssessmentYear: 2026)` in `Cratis.Screenplay.Semantics` | Accepts `ConceptSyntax` or `SemanticConcept`; returns `Concept`, `Findings`, `Proofs`, `Support`, `RequiredVersion`. No enclosing application is invented. |
+| Check a concrete value | `SemanticValidationRules.Check(concept, value)` in `Cratis.Screenplay.Semantics` | Rule results in declaration order; also single-rule and application/type/value overloads. Not a declaration check or a general type validator. |
+| Prove every generated-concept rule | `RuleConsistency.Check(concept, utcAssessmentYear: 2026)` in `Cratis.Screenplay.Semantics.Generation` | Results parallel `concept.Validations`: Proven, Refuted with witness, Unproven with reason. Status is not serialized in ESM. |
+
+Requires Screenplay 4.174.0 (`screenplay --version`) for `RuleConsistency.Check`;
+older consumers must not infer proof from missing serialized status.
+Requires Screenplay 4.185.0 for `SemanticValidationRules.Check`; older consumers
+lack the standalone value-check API.
+Requires Screenplay 4.191.0 for `GenerationStrategyCatalog` and
+`SemanticConceptCheck.Check`; older tools must use whole-model binding, not a
+hand-maintained imitation of admission.
+
+## Check a declaration, not a sample
+
+```csharp
+using Cratis.Screenplay.Diagnostics;
+using Cratis.Screenplay.Semantics;
+using Cratis.Screenplay.Syntax;
+
+var concept = new ConceptSyntax("InviteCode", "String", [], [], SourceLocation.Start)
+{
+    Generation = new("nanoid", SourceLocation.Start) { Size = 8, Alphabet = "ab" }
+};
+var check = SemanticConceptCheck.Check(concept, utcAssessmentYear: 2026);
+Console.WriteLine(check.Support!.Count); // 256
+Console.WriteLine(check.Support.MeetsIdentifierMinimum); // False
+```
+
+The assessment year is nullable (null uses the current UTC year); pass it explicitly
+for reproducible date support and witnesses. Valid years are 1–9899; invalid years
+return PLAY0673 without an assessment. Both overloads accept optional
+`assumeGenerated: false`: set true only for an implicit Uuid concept actually used
+by a generated property, never to invent generation for String/Int.
+
+Findings carry compiler code, severity, message and construct `Target`, not source
+coordinates: a generation-wide finding, an option named by `Option`, or a rule
+named by zero-based `RuleIndex`. Syntax indices count authored rules even when
+some fail binding; proofs follow the inspected semantic validation array.
+Unknown targets are not successful checks. A partial `Concept` is not admission.
+
+Keep `Support.Count` as `BigInteger`; `Bits` is display data and
+`MeetsIdentifierMinimum` can be null for unknown support. Unknown entropy is not
+zero or proof of sufficient entropy. `RequiredVersion` describes this concept
+only. PLAY0683/0684 depend on command-property use and uniqueness, so a concept
+check cannot replace whole-application binding. It also proves no authorization,
+implementation linkage, uniqueness or runtime readiness.
+
+## Check values and interpret proofs
+
+`SemanticValidationRules.Check` overloads accept `(SemanticValidationRule,
+SemanticValue)`, `(SemanticConcept, SemanticValue)` or `(SemanticApplication,
+SemanticTypeReference, SemanticValue)`. The last walks supplied composite and
+collection values. Pass contract-validated inputs; incompatible rule/value kinds
+throw `InvalidSemanticContract` rather than becoming ordinary failed rules.
+
+A `SemanticRuleCheck` carries `Status`, `Rule`, `Message`, optional `Concept` and
+`Pattern`. Status is Satisfied, Failed or NotEvaluable: never treat NotEvaluable
+as a pass. Absent values satisfy evaluable rules except NotEmpty; opaque rules
+remain NotEvaluable. Text compares ordinally, length counts UTF-16 code units,
+and numbers compare as exact decimals. Severity does not waive a failed rule.
+The API allocates nothing and executes no opaque predicate.
+
+All-Proven rules permit unpinned generation only on targets that support it.
+Unproven/Refuted rules need deterministic pins; refuted source contracts must
+first be repaired. Passing samples do not prove containment. Stage supports the
+all-Proven case from 4.115.0; Screenplay's reference runner and Stage's independent
+specification executor still require every reached generated value to be pinned.
+A strategy-shape fixture check is separate from checksum arithmetic: author
+`validate checksum` to enforce arithmetic on pins too.
+
+## References and verification
+
+Read the product references for complete overload/result contracts:
+[concept checks](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/concept-checks.md),
+[value-rule checks](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/value-rule-checks.md),
+and [strategy catalog and proofs](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/generated-values/strategies.md).
+Build a tool against the required Screenplay library; the example's observable
+result is count 256 and identifier minimum False. Then bind and verify the whole
+model: a declaration check is not an executable-model verdict.

package/package/corpus/skills/cratis-screenplay-toolchain/references/generation-strategies-example.md

@@ -1,42 +1,124 @@
-# Generation strategies example (ESM v15)
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
 
-A deterministic UUIDv7 identifier and NanoID receipt, with an accepted response
-and a reused-source rejection. Fixtures, not random seeds, make this executable.
-Contract: the Screenplay documentation pages `generated-values.md` and `generated-values/strategies.md`.
+# Shop generation strategies example (ESM v21)
+
+## Contents
+
+- Choosing a strategy
+- Pinned creation and freshness
+- Attached generation rule
+- When not to
+- Verify
+
+## Choosing a strategy
+
+Requires Screenplay 4.172.0 or later (`screenplay --version`) for pattern/random
+and checksum validation; older compilers refuse PLAY0268.
+Requires Stage 4.118.0 for checksum validation and 4.119.0 for pattern/random
+rendering; older renderers refuse them with STAGE-ESM-042/-028. The attached rule
+below still refuses STAGE-ESM-028. The reference runner uses whole-value fixtures,
+never random seeds.
+
+OrderId stays the high-entropy source identity. InvoiceNumber is a readable
+reference, not a gapless/sequential invoice allocator or secret; its check digit
+catches typos, not forgery. The Int pickup ticket is a value, not an identifier.
+Unique constraints protect short payload codes, while serialized generation
+activates freshness for the whole generated source. Dates/check digits add no
+entropy. The clock fixes every UTC pattern segment, not the random digits.
+
+## Pinned creation and freshness
 
 ```screenplay
-concept InvoiceId : Uuid
-  generate uuidv7
-concept Receipt : String
-  generate nanoid
-module Billing
-  feature Drafts
-    slice StateChange Start
-      command StartDraft
-        invoiceId InvoiceId generated identifier
-        receipt Receipt generated
-        produces event DraftStarted
-          receipt Receipt = receipt
-        returns invoiceId
-      specification StartsWithPinnedValues
-        when StartDraft
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          generated receipt = "abcdefghijklmnopqrstu"
-        then DraftStarted
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          receipt = "abcdefghijklmnopqrstu"
-        then returns "00112233-4455-7677-8899-aabbccddeeff"
+concept OrderId : String
+  generate typeid "order"
+concept InvoiceNumber : String
+  generate pattern "INV-{yyyy}{MM}-#{7}" checksum luhn
+  validate checksum luhn
+concept TicketNumber : Int
+  generate random 100000..999999
+module Shop
+  feature Orders
+    slice StateChange Place
+      constraint UniqueInvoiceNumber
+        unique invoiceNumber on OrderPlaced
+      constraint UniquePickupTicket
+        unique pickupTicket on OrderPlaced
+      command PlaceOrder
+        orderId OrderId generated identifier
+        invoiceNumber InvoiceNumber generated
+        pickupTicket TicketNumber generated
+        produces event OrderPlaced
+          invoiceNumber InvoiceNumber = invoiceNumber
+          pickupTicket TicketNumber = pickupTicket
+        returns orderId
+      specification PlacesWithPinnedValues
+        given clock "2026-10-02T09:00:00Z"
+        when PlaceOrder
+          for "order_0000000000e008000000000000"
+          generated invoiceNumber = "INV-202610-00000004"
+          generated pickupTicket = 123456
+        then OrderPlaced
+          for "order_0000000000e008000000000000"
+          invoiceNumber = "INV-202610-00000004"
+          pickupTicket = 123456
+        then returns "order_0000000000e008000000000000"
       specification RejectsAUsedGeneratedSource
-        given DraftStarted
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          receipt = "abcdefghijklmnopqrstu"
-        when StartDraft
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          generated receipt = "abcdefghijklmnopqrstu"
+        given clock "2026-10-02T09:00:00Z"
+        given OrderPlaced
+          for "order_0000000000e008000000000000"
+          invoiceNumber = "INV-202610-00000004"
+          pickupTicket = 123456
+        when PlaceOrder
+          for "order_0000000000e008000000000000"
+          generated invoiceNumber = "INV-202610-00000004"
+          generated pickupTicket = 123456
         then error "A generated event source already has facts; retry the command with a fresh generated value."
 ```
 
-The rejection appends no new facts and returns no response. v15 guards the whole
-source even if the old fact uses another stream or event type. Removing every
-serialized generation strategy restores the earlier Unguarded contract, not an
-alternative way to make a stale-source specification pass.
+The rejection appends no new facts and returns no response. Freshness guards the
+whole source even if its old facts use another stream or event type. Without a
+serialized strategy the model is Unguarded, even if generated-concept rules
+select v20; removing strategies is not a way to repair stale-source behavior.
+Pin failure against shape or authored rules is a server Contract rejection,
+never a client validation failure or a reason to redraw. Without `validate
+checksum`, a fixture checks suffix shape only, not arithmetic. Without `given
+clock`, date segments check digit widths only, never today's date.
+
+## Attached generation rule
+
+An implementation-specific tenant-bearing reference can instead attach one
+generation rule; its entropy is unknown, not zero. The body gets only Now and
+Tenant. The reference evaluator consumes a String fixture without running code:
+
+````screenplay
+concept TenantOrderReference : String
+  generate rule TenantOrder
+    ```csharp
+    return $"{context.Tenant}:order_{context.Now:yyyyMMdd}-{Guid.NewGuid():N}";
+    ```
+module Shop
+  feature Orders
+    slice StateChange ReserveReference
+      command ReserveReference
+        reference TenantOrderReference generated
+        returns reference
+      specification UsesThePinnedReference
+        when ReserveReference
+          generated reference = "shop-eu:order_example"
+        then returns "shop-eu:order_example"
+````
+
+## When not to
+
+Keep client-minted values as inputs. Generation is neither idempotency nor
+authorization. Use an allocator for gapless numbering, and preserve secret
+classification rather than trying to bind generated credentials. A short code's
+uniqueness constraint protects its payload claim, not source freshness or retry
+safety after an unknown append outcome.
+
+## Verify
+
+Compile with `screenplay <file> --warnaserror`; then `screenplay test <file>` must report
+all selected specifications passed, none failed or unsupported. Passing reference
+specifications do not prove target support or that attached generation code runs.

package/package/corpus/skills/cratis-screenplay-toolchain/references/language-admission.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. -->
+
+# Language admission: batches, described bodies, text and reads
+
+Select the highest version required by constructs in the model. A newer version
+alone never opts into either application mode. Consumers must explicitly admit
+exact language/semantic pairs; binding, reference execution and rendering are separate.
+
+| ESM | Selecting construct | Binding/reference behavior | Stage boundary |
+| --- | --- | --- | --- |
+| v22 | Application-root `reaction batches atomic` | Direct productions per trigger occurrence and each selected refusal branch are separate atomic batches; commands remain independent | v22 refused STAGE-ESM-016; mode in admitted v23–v25 refused STAGE-ESM-043 |
+| v23 | Pending `handler implementation` beside unconditional `produces` | Payload-only body; PLAY0695 information; reaching body gives Unsupported ImplementationBody | v23 admitted, body refused STAGE-IMPL-002 in renderer/Host/executor, even Stub mode |
+| v24 | `contains`, `not contains`, `starts with`, `ends with` property/concept rules | Ordinal UTF-16, absent optional passes; not text-condition operators | v24 admitted; semantic Host/executor and generated ordinal comparisons preserve rules |
+| v25 | Application-root `command reads protected` | Admitted reads in requirements/mappings, absence Validation, matching decide/commit changes Conflict | v25 admitted; protected reads refused STAGE-ESM-044 in renderer/Host/executor |
+
+Requires Screenplay 4.181.0 or later (`screenplay --version`) for atomic batches; older compilers cannot admit the preamble.
+
+Requires Screenplay 4.182.0 or later (`screenplay --version`) for described handlers; older binders report PLAY0268.
+
+Requires Screenplay 4.184.0 or later (`screenplay --version`) for literal text rules; older binders do not admit those rules.
+
+Requires Screenplay 4.193.0 or later (`screenplay --version`) for protected reads; older binders retain PLAY0271/PLAY0268.
+
+Requires Stage 4.124.0 for v24 text-rule admission (`cratis --version` identifies the CLI bundle); older renderers refuse v24 with STAGE-ESM-016. V23 admission alone does not implement described bodies.
+
+Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. Protected reads still refuse STAGE-ESM-044, including on legacy paths; no artifacts are emitted.
+
+Read [atomic batches and event-source invocation mappings](../../cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md)
+for atomic boundaries and the source-identity mapping prerequisite. Start new models
+with atomic mode; explicitly review opt-in for legacy models. Keep protection when
+Stage refuses: do not remove the declaration or promise a target release date.
+
+Read [described handlers](../../cratis-screenplay-command-surface/references/described-handlers.md)
+for the payload result contract and [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
+for finite event-source-keyed view admission, single-level paths and repair guards.
+Text comparisons and matching are in [text and match rules](../../cratis-screenplay-command-surface/references/text-and-match-rules.md).
+`matches` uses the portable linear dialect without selecting a new ESM version;
+PLAY0699 refuses nonportable constructs, PLAY0367 invalid syntax, PLAY0787 warns
+on exact Studio text-rule patterns and offers a literal-rule repair.
+
+Stage's semantic engines admit exact v1–v21 and v23–v25 pairs. V22/v26 and mixed
+pairs refuse STAGE-ESM-016. Admission of v23–v25 is not admission of described bodies,
+atomic mode or protected reads. A CLI may bundle an older compiler/Stage pair: run no-write render
+admission rather than transferring a standalone verdict. Pattern diagnostics arise
+in Screenplay before rendering; diagnostic arguments add no ESM version or new tool.

package/package/corpus/skills/cratis-screenplay-toolchain/references/preferred-syntax.md

@@ -5,7 +5,7 @@
 
 Use these forms when writing or reviewing `.play`. Acceptance of an older
 spelling is not a recommendation to teach it. Information diagnostics do not
-fail `--warnaserror`; the corpus verification gate rejects the nine style codes
+fail `--warnaserror`; the corpus verification gate rejects the eleven style codes
 below even when a fence declares `expect`, unless an exact, reasoned migration
 exception exists in the verifier's preferred-syntax allowlist. That allowlist also
 covers deliberate legacy explanations in prose; stale entries fail.
@@ -23,6 +23,8 @@ covers deliberate legacy explanations in prose; stale entries fail.
 | Imports | Import only declarations not already declared by the application | Importing the application's own names | PLAY0290 (warning) |
 | Interaction guard | Block-form `when` alternatives | Opaque interaction `where` on click, double click or select | PLAY0564 (warning or information) |
 | Projection transition cardinality | Source binding emits `One` | Constructed/deserialized ESM v1–v3 `ZeroOrOne` / `Many` | PLAY0445 (warning; ESM-only, not a source spelling) |
+| Command decision reads | `command reads protected` after reviewing every read's admission, absence and conflict semantics | Eligible legacy command reads without the application-root preamble | PLAY0786 (information; individual typed repair review, never fix-all) |
+| Literal text rules | `starts with`, `ends with`, `contains`, `not contains` or equality, preserving message and severity | Exact deprecated Studio `matches` shapes | PLAY0787 (warning; not arbitrary regex rewriting) |
 
 `query Q => observable?` is not a legacy optional type suffix and has no keyword
 replacement. Reaction/Translate `where` is current syntax, not an interaction