@cratis/pi 7.62.0 → 7.63.0

package/package/corpus/skills/cratis-screenplay-specifications/references/generated-fixtures.md

@@ -1,31 +1,42 @@
-## Generated fixtures and return expectations (ESM v7 and v15)
+# Generated fixtures and return expectations
 
-### Choosing a strategy
+## Contents
+
+- Choosing a strategy
+- When not to
+- Fixtures and outcomes
+
+## Choosing a strategy
 
 Use the [shop example](../../cratis-screenplay-command-surface/references/shop-generation.md):
 pin CustomerId (`cus_` + ULID), OrderId (TypeID) and InviteCode (NanoID) as
 whole values. ApiKey stays secret with no executable generation; do not write a
 passing issuance spec that invents its .NET Bytes(32) factory in Screenplay.
-OrderId pins do not realize Arc's received-time/tenant context either.
+Pin InvoiceNumber's whole date/checksum reference and TicketNumber's integral
+pickup-ticket value too; do not use numeric text for Int fixtures.
 
 Choose the concept's strategy for the job, then pin a whole value matching it:
 `for` for its generated identifier, named `generated` fixtures for other values.
 Use the shared [strategy reference](../../cratis-screenplay-command-surface/references/generated-values-and-responses.md)
-for UUID, time-ordered, typed/opaque text and byte-budget choices and exact shapes.
-`given clock` supplies `$context.occurred`, not a generated time-ordered ID;
+for UUID, time-ordered, typed/opaque text, byte budgets, finite patterns and Int
+range choices and exact shapes.
+`given clock` supplies `$context.occurred` and pattern UTC date segments, not a generated time-ordered ID;
 a seed is not a portable fixture.
 
-### When not to
+## When not to
 
 Pins do not prove randomness, authorization, idempotency, storage freshness or
 secret safety. Client-minted IDs stay inputs; gapless invoice numbering needs an
-allocator, not a random fixture. Pattern/random/rule and secret generation remain
-unadmitted. Source: Screenplay
+allocator, not a random fixture or pattern. Check digits catch typos, not forgery;
+short payload codes need uniqueness enforcement separate from source freshness.
+Pattern/random/rule and checksum validation bind as v21. Stage renders
+pattern/random/checksum under the version gates below; `generate rule` remains
+STAGE-ESM-028. Generated secrets remain refused. Source: Screenplay
 `Documentation/screenplay/generated-values/choosing.md`.
 
-### Fixtures and outcomes
+## Fixtures and outcomes
 
-A compiler that admits ESM v7 binds and runs these; Stage renders supported UUID/String generation strategies,
+A compiler that admits ESM v7 binds and runs these; Stage renders supported UUID/String and Int random generation strategies,
 scalar/named responses, fixtures and `then returns`. Unsupported types/result combinations
 remain `STAGE-ESM-028`/`-038`; preserve refused specifications as gap-fill contracts. The model and rules are in `cratis-screenplay-command-surface`; the
 complete threaded model is the linked shop example. The excerpt below belongs
@@ -62,17 +73,37 @@ specification RegistersWithPinnedValues
   own destinations. For commands without a generated identifier `when ... for` keeps the destination assertion.
   UUID fixtures require canonical lowercase hyphenated form. From v15, pins must also match
   exact strategy size, case, UUID version/variant and zero trailing encoding bits; invalid pins are
-  Contract rejections. Earlier models check canonical UUID type, not its version.
+  Contract rejections. A generated concept with rules selects v20 and checks pins
+  against both shape and rules, including implicit UUID. Rule failures are
+  `Rejected(Contract)` with `Generated fixture '<property>' fails concept '<Concept>' rules`,
+  never client validation failures or redraws. Earlier rule-free implicit-UUID
+  models check canonical UUID type, not its version.
 - A serialized concept generation strategy selects v15 and Guarded whole-source freshness for all
   generated destinations, including implicit UUIDs. Reusing a generated source with existing facts
-  rejects the entire command with Concurrency, without append, response or silent retry. Below v15
-  fixtures retain legacy reuse. See the complete [strategy example](../../cratis-screenplay-toolchain/references/generation-strategies-example.md)
+  rejects the entire command with Concurrency, without append, response or silent retry.
+  Models without a serialized strategy retain legacy reuse even when rules select v20. See the complete [strategy example](../../cratis-screenplay-toolchain/references/generation-strategies-example.md)
   and command-surface `references/generated-values-and-responses.md` for tagged sources.
-- `given clock` supplies `$context.occurred`; it does not synthesize UUIDv7, ULID or
-  TypeID from that instant. Pin the whole identifier, never a seed. Stage's
-  time-ordered factories use wall clock, not command-receipt time, and its clock
-  specifications remain unsupported. Sources: Screenplay
+- `given clock` supplies `$context.occurred` and requires all pattern date segments
+  to match the same UTC instant, including offset rollover and leap days. Without
+  a clock the reference runner checks digit widths, never today's wall clock.
+  Checksum pins check arithmetic only with an authored `validate checksum` rule;
+  a generation modifier alone checks suffix shape. It does not synthesize UUIDv7,
+  ULID or TypeID: pin the whole identifier, never a seed. Stage time-ordered
+  factories use receipt time; admitted command clock specs render. Sources: Screenplay
   `Documentation/screenplay/generated-values/choosing.md`; Stage
   `Documentation/reference/generated-values-rendering.md`.
+- Attached generation bodies are not run: pin the resulting String;
+  an opaque validator still yields Unsupported. Stage allows unpinned rendered
+  generation only when every concept rule is Proven and the expectations support
+  relational captures. Unproven/Refuted rules need pins (-038); invalid pins fail
+  STAGE-ESM-011. Opaque/unsupported rules refuse -005 before pin evaluation.
+  Screenplay's reference runner and Stage's independent executor always need pins.
 - A reaction-invoked command that reaches generation is `Unsupported(IdentityAllocation)` (no fixture channel); a
   response-only command runs and its response is discarded.
+
+Requires Screenplay 4.164.0 (`screenplay --version`) for v20 rule-bearing generated pins, 4.172.0 for v21 finite/rule strategies; older compilers refuse PLAY0268.
+Requires Stage 4.95.0 for command clock specs and 4.109.0 for v20 rule-bearing pins; older renderers refuse those shapes.
+Requires Stage 4.115.0 for v21 admission/all-Proven unpinned rendering, 4.117.0
+for warning/info generated-concept rules, 4.118.0 for checksum validation and
+4.119.0 for pattern/random. Older renderers require rule-bearing pins or refuse
+the respective rules/strategies with -038/-042/-028. `generate rule` remains -028.

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

@@ -1,3 +1,6 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
 # The specification vocabulary
 
 This reference holds the given/when/then construct table and the enumeration and DateTime literal rules.
@@ -17,7 +20,7 @@ This reference holds the given/when/then construct table and the enumeration and
 | `given clock "<instant>"` | the ISO 8601 instant the scenario happens at |
 | `when clock "<instant>"` | the clock reaches an instant; scheduled reactions that are due run |
 | `when trigger <Trigger>` | an application trigger fires with the values beneath it |
-| `given capture` / `when capture <Capture>` | an earlier and the current record of a capture's source |
+| `given capture` / `when capture <Capture>` | earlier/current records for non-event sources; for `source events` use typed `given <Event>` / `when append <Event>` (PLAY0701) |
 | `generated <name> = <value>` | beneath `when <Command>`: the fixture for a generated property other than the identifier (ESM v7); `for` beneath the `when` supplies the generated identifier |
 | `then returns [<value>]` | the command's response (ESM v7): `then returns "<uuid>"` for a scalar, `then returns` with named `field = value` lines for a subset of a record |
 | `then <EventType>` | an expected new event |
@@ -32,6 +35,16 @@ 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}]` |
 
+## Parse and binding diagnostics
+
+PLAY0358 is a syntax error; PLAY0388 also occurs at parse time for extra text
+after `then denied`. PLAY0350, PLAY0352, PLAY0388 for mixed outcomes, PLAY0389 and
+the one-rejection rule PLAY0273 occur only at binding. Source validation alone
+will not report them: check executable diagnostics as well. Clock instants need
+an ISO 8601 offset or `Z`, for example `"2026-10-05T08:00:00Z"` (PLAY0461).
+
+## Literal spellings
+
 An enumeration value binds whether it is written bare
 (`status = sent`), qualified (`status = InvoiceStatus.sent`) or quoted, and a
 `DateTime` value binds as a plain ISO 8601 instant (`"2026-10-05T08:00:00Z"`).

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

@@ -26,17 +26,15 @@ Read [references/product-sources.md](references/product-sources.md) when checkin
 - Not for: projection and query syntax, reactions and captures, writing the specifications
   themselves (`cratis-screenplay-scenario-coverage`), Chronicle C# mechanics
   (`cratis-chronicle-event-modeling`). See Route near misses.
-- Model-first applies: when an accepted model covers the scope, change the model and its
-  specifications, not code. Do not weaken authorization, `pii` or rules to make a model compile.
+- Apply model-first per `cratis-screenplay-modeling-lifecycle`; never weaken
+  authorization, `pii` or rules to compile.
 
 ## Interview phase
-**Skip if** the user or the model already states the stream identities, who owns each module, how
-much autonomy each side has, the external systems, and rough growth. Otherwise ask only what is
-missing, one question at a time, with options. **Unattended:** assume the most conservative
-option, mark it `ASSUMED` in the slice or module `documentation` and in the session `STATE.md`
-(`.ai-work/screenplay/<model-slug>/STATE.md`), and continue.
-
-Ask only what is missing: (1) instance - what real-world thing the stream is about; (2) competition - what must never happen when two people act at once; (3) retry - what a repeated request should see; (4) ownership; (5) growth; (6) change - whether the event was ever stored in a running system. Read [references/interview-batch.md](references/interview-batch.md) for each question's follow-up; ownership options are in `references/boundaries.md`.
+Read [interview prompts](references/interview-batch.md) when identity, competition,
+retry, ownership, growth or stored-event history is unsettled. Ask only missing
+questions, one at a time; ownership options are in `references/boundaries.md`.
+Unattended work takes the conservative option and marks it `ASSUMED` in model
+`documentation` and `.ai-work/screenplay/<model-slug>/STATE.md`.
 
 ## Procedure
 1. **Establish identity and membership.** For every `concept XId` used as an `identifier`, write
@@ -87,14 +85,10 @@ Ask only what is missing: (1) instance - what real-world thing the stream is abo
    (PLAY0270), not runtime propagation or generated C# `[Subject]`. Without a
    supplied subject, the runtime defaults to the event source; see command-surface
    `references/compliance.md` for allowed types and the policy/encryption distinction.
-5. **Plan evolution** with `references/evolution.md`: classify each event change (additive,
-   meaning change, rename, removal, split or merge) and write its compatibility scenarios before
-   editing. Admit the **release baseline** in the release job; admitted
-   revisions need `newGeneration`. Modes/CLI/MCP: `references/evolution.md`.
-   Pin persisted/public enum member numbers before reordering or removing members (`references/evolution.md`, "Enum member numbers").
-
-   Renames and other identity-affecting edits are made by the identity owner (the
-   identity procedure in `cratis-screenplay-modeling-lifecycle`).
+5. **Plan evolution**: read `references/evolution.md` before editing stored contracts
+   for change classification, compatibility scenarios and enum-number safety.
+   After release-baseline admission, revisions need `newGeneration`. Identity-affecting edits belong to the
+   identity owner (`cratis-screenplay-modeling-lifecycle`).
 6. **Test ownership and interfaces** with `references/boundaries.md`: ownership interview,
    interface and processor inventory, one real interaction walked across each boundary, coupling
    check. Keep team, module, stream and deployment boundaries distinct; inbound facts via
@@ -108,15 +102,19 @@ Ask only what is missing: (1) instance - what real-world thing the stream is abo
 - `identifier` on an event property is PLAY0019; the source id is never payload by declaration.
   Copying it as a payload value is PLAY0469 (information, warning for inline events).
 - In the executable model a production's `for` must resolve to the command's scalar identifier:
-  one command writes one stream declaratively (a handler is never admitted).
+  one command writes one stream declaratively; described handlers bind v23 but
+  their payload-only contract does not grant arbitrary destinations.
 - Constraint names are application-wide identities (PLAY0392); properties must be declared
   directly on the event (PLAY0391); never mix event and property rules under one name (PLAY0135);
   `ignore casing` is not allowed on `unique event` (PLAY0393).
 - Generations are declared in full, numbered 1..N without gaps, in the same slice (PLAY0446-0448); `id` pins are shared by all generations and unique application-wide (PLAY0472); `storedName` needs ESM v16. See `references/evolution.md` ("Generations, pins and storedName diagnostics").
 
-- `reads` is PLAY0271 and `require` over read-model paths is PLAY0268 at binding. A `concurrency`
-  block compiles but is PLAY0271 at binding. Keep both when they state real intent; they are not
-  protection. `description` text never reaches rendered code: a rule that lives only in prose is
+- Application-root `command reads protected` admits eligible reads and single-level
+  requirement/mapping paths (v25). Absence rejects, matching decide/commit changes
+  conflict. Legacy reads remain PLAY0271/PLAY0268; `concurrency` remains unbound and
+  combining it with protected reads is PLAY0783. Read
+  [protected reads](../cratis-screenplay-command-surface/references/protected-reads.md)
+  for admission and Stage's STAGE-ESM-044 protected-read refusal (the v25 pair itself is admitted). `description` text never reaches rendered code: a rule that lives only in prose is
   unenforced there.
 - `pii` and `secret` bind as ESM v13;
   enum/identity compliance and protected events with explicit subject marks still
@@ -144,6 +142,12 @@ Requires Chronicle 19.59.6 or later (19.59.3 for the InMemory provider) for the
 - 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
   is not one transaction. Declared semantics are not a passed concurrency test.
+- 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
+  [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
   value; use `unique event` for a fact that is genuinely once-only in its lifecycle, without
   blocking legitimate repeated operations just to make retries safe.

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

@@ -80,8 +80,8 @@ For each affected boundary, identify:
 
 Use declaration addresses, not copies of payloads. Per slice, also record the events it consumes
 and which slice produces them, for orientation, not as a build order. A command or reaction may
-consult another slice's view (`reads`; unprotected in `.play`, see `consistency-and-concurrency.md`
-section 3); a slice calls another slice's command only through `invokes`.
+consult another slice's view (`reads`; eligible commands opt into v25 protection,
+trigger reads cannot; see `consistency-and-concurrency.md` section 3 for target gaps); a slice calls another slice's command only through `invokes`.
 
 ### Responsibility matrix and ownership timeline
 One compact matrix per feature shows who owns what; the timeline shows where a fact crosses.

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

@@ -57,8 +57,8 @@ observed legacy check from verified atomic protection.
 | several command properties / constants | `require` | runs after property rules, before production |
 | a value across all sources | `unique <prop> on <Event>` | value owned by one source; same source may re-claim |
 | a fact at most once per source; mutually exclusive facts | `unique event` (+ `released by`) | covers simple lifecycle transitions |
-| state-dependent rule not reducible to the supported uniqueness/release semantics (a balance, capacity, "only if approved") | no protected decision read in `.play` today | state it as `reads` + `require … message`, mark NOT enforced, name the target enforcement (below) |
-| a view (read model) | an unguarded materialized read is not protection | views lag; `reads` is PLAY0271, `require` over views PLAY0268 at binding (expected in design mode) |
+| state-dependent rule (balance, capacity, "only if approved") | eligible `reads` + `require` under `command reads protected` (v25) | required absence rejects; matching intervening facts conflict. Payload-key fan-in, joins, reducers and other refused shapes remain target gaps |
+| a view (read model) | unguarded materialized reads are not protection | legacy command and trigger reads remain unprotected; Stage refuses protected reads (STAGE-ESM-044), so reference protection is not target realization |
 
 ## 3. Record each state-dependent rule that the model cannot enforce
 Never accept the caller's copy of the state: `currentStatus Status` on the command with
@@ -67,7 +67,13 @@ input (`confirmsX == true`) standing in for the rule. Never move the rule into `
 `implementation hint` prose; a description renders only as an XML doc comment (Stage#178), so prose alone leaves
 the rule unenforced in rendered scope.
 
-Right: write the rule as stated intent and mark it unenforced.
+First inspect [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md):
+opt eligible command reads into v25, retain absence/conflict specifications and verify
+target consistency separately. Stage admits v25 but refuses protected reads (STAGE-ESM-044). A payload-keyed
+fan-in such as the course-capacity example remains refused; the preamble is not a
+blanket admission of arbitrary projections.
+
+For legacy models without opt-in or refused shapes, write stated intent and mark it unenforced.
 - `reads <View> as x by …` plus `require <expr over x> message "…"` on the command (the
   `StateChange` slice in `streams-example.md`). Binding reports PLAY0271 / PLAY0268; that is
   expected in design mode, so keep the lines. Do not remove them to pass a tool.

package/package/corpus/skills/cratis-screenplay-streams-and-consistency/references/multi-service-models.md

@@ -115,9 +115,10 @@ module Billing
   another reason each service has its own folder.
 - A capture keys on the incoming content, so the contract carries the identity
   the consumer keys on.
-- The producer's publication specification runs in the reference evaluator; the
-  consumer's capture over events binds but evaluates as typed Unsupported. Specify
-  the consumer's private behavior downstream of the capture.
+- Both sides run in the reference evaluator: the producer's publication
+  specification, and the consumer's capture over events, which a specification
+  drives by presenting the consumed public event (`when append <Event>`;
+  Requires Screenplay 4.171.0).
 - Syntax, publication semantics and the full rules: read
   `cratis-screenplay-automations-and-translations`
   `references/public-events-and-direction.md`.

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

@@ -1,5 +1,12 @@
 # Example: streams, constraints and a recorded rule
 
+Legacy control: no `command reads protected` preamble is declared. The course-capacity
+payload-key fan-in remains refused even with opt-in; eligible active-enrolment reads
+can protect under v25, but reads plus concurrency cannot combine (PLAY0783). Read
+[protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
+for admission and Stage's protected-read refusal (STAGE-ESM-044). The legacy diagnostics below describe this
+control, not a blanket refusal of command reads.
+
 A complete design-mode model for course enrolment. It shows one business identity per stream,
 cross-stream references as payload, three kinds of uniqueness constraint, a state-dependent
 rule recorded as **NOT enforced in the model today**, a declared `concurrency` scope, and an

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

@@ -8,12 +8,9 @@ license: MIT
 
 Read [preferred syntax](references/preferred-syntax.md) when writing or reviewing `.play`.
 
-Which tool to run, what its result means, and what each tool can and cannot admit. This
-skill answers "does it compile, bind, render, and which compiler said so". The method
-(what to model, in which order, with which gates) lives in
-`cratis-screenplay-modeling-lifecycle`; construct syntax lives in the construct skills
-(`cratis-screenplay-command-surface`, `-projections`, `-read-surface`,
-`-captures-and-reactions`, `-specifications`, `-ui-composition`).
+This skill owns tool selection, verdict meaning and admission. Modeling method
+lives in `cratis-screenplay-modeling-lifecycle`; construct syntax lives in command,
+projection, read-surface, capture/reaction, specification and UI skills.
 
 ## Locate the model
 
@@ -28,7 +25,11 @@ bundled in the CLI are different releases, and the bundled one can be older; a c
 standalone tool binds may be refused or unrendered through the CLI. Capabilities that need a
 minimum release carry a one-line `Requires ...` note in the reference that teaches them.
 
-For exact diagnostic codes, MCP names/parameters and standalone CLI options, search the large published [references/screenplay-contract.json](references/screenplay-contract.json), named by [references/screenplay-contract.version](references/screenplay-contract.version), rather than loading it in full. Locate a diagnostic by its exact `code` (for example `"code": "PLAY0029"`), a tool by its exact `name` (for example `"name": "read-workspace"`), or a command in `cliCommands`; read the matched object for retirement, parameters or options. [references/screenplay-contract-exceptions.json](references/screenplay-contract-exceptions.json) records reasoned exceptions for superseded statements; it does not change the current contract.
+Search [screenplay-contract.json](references/screenplay-contract.json), not its
+whole contents, for exact diagnostic `code`, tool `name` or `cliCommands` options.
+Its version is [screenplay-contract.version](references/screenplay-contract.version).
+Read [contract exceptions](references/screenplay-contract-exceptions.json) when a
+superseded statement needs context; exceptions do not change the contract.
 
 ## Ground rules
 
@@ -101,8 +102,11 @@ changes with the root folder name.
   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
-  read-surface [equality filters](../cratis-screenplay-read-surface/references/equality-filters.md). No handler (PLAY0268, with or without `implementation`/`hint`); `reads` and
-  `concurrency` do not bind (PLAY0271); concept compliance binds as v13 (precise refusals: command-surface `references/compliance.md`);
+  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.
+  Eligible protected reads opt into v25; legacy reads and `concurrency` retain PLAY0271.
+  Concept compliance binds as v13 (precise refusals: command-surface `references/compliance.md`);
   generated values and `returns` responses bind (ESM v7, `references/generated-responses-example.md`). Read [references/executable-example.md](references/executable-example.md) when you need a small StateChange and StateView model that binds executable, [references/pdl-example.md](references/pdl-example.md) when writing projection forms that bind and run, and [references/automation-translate-example.md](references/automation-translate-example.md) when writing Automation and Translate slices (ESM v6).
 - **Renderable** (V5): `references/renderable-subset.md` has the admission table. The CLI admits through
   its newest known ESM version to construct checks; supported UUID/String
@@ -119,18 +123,22 @@ changes with the root folder name.
   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`.
-- **Enum numbers (v12):** non-positional enum numbers bind; canonical
-  `numbers` parallels `values`. Positional pins preserve earlier executable
-  bytes/version. Specifications still use names. Stage admits v12 and emits `Member = N`. Syntax:
-  command-surface `references/enum-numbers.md`; errors PLAY0667–0670 and opt-in
-  `enum-pinning` hint PLAY0671: `references/diagnostics.md`.
-- **Concept strategies (v15):** concept strategies and Guarded freshness; strict fixture shapes,
-  no silent retry. Read [references/generation-strategies-example.md](references/generation-strategies-example.md)
-  and command-surface `references/generated-values-and-responses.md` for supported strategies/refusals.
-- **v17–v20:** recovery/no-event assertions (v17), query Validation errors (v18),
-  invocation refusal branches (v19), generated-concept rules (v20). Read
-  `references/executable-subset.md` when choosing a version; specifications and
-  command-surface references own examples. Newer binding is not render admission.
+- **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
+  [generation strategies](references/generation-strategies-example.md) for Guarded
+  freshness and strict fixtures, and command-surface
+  `references/generated-values-and-responses.md` for strategy/refusal depth.
+- **v17–v21:** recovery/no-events (v17), query Validation errors (v18), refusal
+  branches (v19), generated-concept proofs (v20), pattern/random/rule/checksum (v21).
+  Read `references/executable-subset.md` for version prerequisites and
+  `references/diagnostics.md` for proof/support failures. Binding is not rendering.
+  Tool/renderer authors: read [references/generation-checks.md](references/generation-checks.md)
+  when discovering strategy options, checking one concept or value, or consuming rule proofs.
+- **v22–v25:** read [language admission](references/language-admission.md) for atomic
+  batches, described handlers, text rules, protected reads and Stage refusals.
+  Read [diagnostic arguments](references/diagnostic-arguments.md) for MCP/JSON subjects:
+  code and typed arguments, never message parsing.
 - **Caller/compliance metadata:** `$identity` aliases caller built-ins;
   additional identity details are metadata and executable reads still refuse.
   Bare `pii`/`secret` replace legacy spellings; `pii personal` repeats one marker
@@ -186,7 +194,7 @@ Read [references/diagnostics.md](references/diagnostics.md) when a PLAY, STAGE o
 11. Declare an event once, in its producing slice.
 12. Quoted `import "glob"` is your own files; unquoted `import Ctx.Event` is a foreign
     contract and does not bind.
-13. A handler never binds; `numbers exact` never binds; descriptions render only as XML doc comments, never as behavior.
+13. Pending described handlers bind but do not execute their bodies; attached handlers and `numbers exact` do not bind. Descriptions render as XML doc comments, not behavior.
 
 ## Gate
 

package/package/corpus/skills/cratis-screenplay-toolchain/references/cheat-sheet-example.md

@@ -2,7 +2,9 @@
 
 One complete document with every construct family. Design mode, not executable. Prose rules: [cheat-sheet.md](cheat-sheet.md); what binds: [executable-subset.md](executable-subset.md).
 
-Binding blockers: unquoted import, `reads` (PLAY0271), `starts with`. Caller-supplied collection equality filters bind as ESM v14; context and single-result filters remain blocked. Executable shapes are in the sibling examples. `RecordingAPayment` lists the `InvoiceClosed` cascade; an older bundled compiler rejected it with a false PLAY0285 ("outcome cannot be produced by 'RecordPayment'").
+Binding blockers in this legacy control without protected-read opt-in: unquoted
+import, legacy `reads` (PLAY0271), condition-only `starts with` (PLAY0268).
+Property/concept text rules bind v24; eligible protected reads bind v25. Caller-supplied collection equality filters bind as ESM v14; context and single-result filters remain blocked. Executable shapes are in the sibling examples. `RecordingAPayment` lists the `InvoiceClosed` cascade; an older bundled compiler rejected it with a false PLAY0285 ("outcome cannot be produced by 'RecordPayment'").
 
 Concept compliance itself binds as ESM v13; reasons remain report-only PLAY0270. Stage renders v13 concept
 protection. Binder-only PLAY0268 refusals and subject-lineage limits: command-surface `references/compliance.md`.

package/package/corpus/skills/cratis-screenplay-toolchain/references/cheat-sheet.md

@@ -10,11 +10,23 @@
 - `$context.` paths (command `produces`)
 - `$eventContext.` (projections)
 - PDL quick reference (most forms are compiled in `pdl-example.md` or `cheat-sheet-example.md`; `remove via join` and `$eventContext.occurred` are not)
+- Generated values and proofs
 - Specification forms
 
 Released boundary forms: `public event X`, `event X from "store"`, Translate
 `direction inbound|outbound`, event-target `projection/reducer P => PublicEvent`,
-and capture `source events` with `from ForeignEvent` select v9. Read
+and capture `source events` with `from ForeignEvent` select v9.
+For event captures, present `given <FromEvent>` / `when append <FromEvent>`, not
+capture records (PLAY0701). The key must be required on every `from` event, never
+a context key (PLAY0700). PLAY0701 repairs only an unambiguous single-`from` capture;
+PLAY0700 has no automatic repair.
+Requires Screenplay 4.171.0 or later (`screenplay --version`); older runners do not
+deliver these events to captures.
+A directionless Translate reacting without a `from` route to its own capture's
+append warns PLAY0694 (fails `--warnaserror`): move the reaction to Automation,
+keeping the capture in Translate. No automatic split.
+Requires Screenplay 4.176.0 or later; older compilers leave that shape unchecked.
+Read
 [public contracts](../../cratis-screenplay-automations-and-translations/references/public-events-and-direction.md).
 View properties use trailing `key`; multipart `by` query/read blocks remain
 PLAY0268, not v10. Read [named keys](../../cratis-screenplay-read-surface/references/named-keys.md).
@@ -71,9 +83,14 @@ remain unadmitted. Compile and test each relevant fixture with the chosen tool.
   require that position. Source preambles precede declarations.
 - Strings: `"..."`, escapes `\" \\ \n \r \t`; other backslashes kept (regex `"^INV-\d{6}$"` works).
 - Structured values: single-line JSON, quoted keys (`[{"sku": "A-1", "quantity": 2}]`).
+- Literal property/concept text rules use `contains`, `not contains`, `starts with`,
+  `ends with` with quoted operands (v24, ordinal UTF-16). Portable `matches` refuses
+  nonportable constructs with PLAY0699; exact Studio patterns warn PLAY0787.
+  Read command-surface [text and match rules](../../cratis-screenplay-command-surface/references/text-and-match-rules.md).
 - One condition grammar (policy `require`, `produces when`, `require`, reaction `where`): `and`
   binds tighter than `or`; operators `== != > >= < <= contains`, `starts with`; claims use
-  `claim "x" matches "v"` (not `==`: PLAY0120).
+  `claim "x" matches "v"` (not `==`: PLAY0120). Text operators here are condition-only
+  authoring syntax (PLAY0268 at binding), not the admitted property text rules.
 - Keyword escape `@name` for properties named `tag`, `authorize`, `produces`, `reads`, `file`,
   `validate` (enum value), `sequence`, `occurred`, `causedBy`, `namespace`, `correlation`,
   `causation`, and projection `key`/`parent`/`with`.
@@ -153,6 +170,34 @@ collections (path below them: PLAY0297 E). Unknown member: PLAY0295/0296 W.
 - One `every`/`all` block per level for the executable model (else PLAY0268).
 - Templates (`` `${a}` ``) and `$causedBy` parse but do not bind (PLAY0268).
 
+## Generated values and proofs
+
+Choose readable invoice/order references with `generate pattern "INV-{yyyy}{MM}-#{7}" checksum luhn`
+on a String concept and author `validate checksum luhn` separately. `#`, `?`, `*`
+mean digit, uppercase letter, letter-or-digit; ASCII classes and repeats up to
+64 are finite. UTC segments are `{yyyy}`, `{yy}`, `{MM}`, `{dd}`. Int
+`generate random 100000..999999` is inclusive; `generate rule Name` attaches one
+file/tagged fence with Now/Tenant context and unknown entropy. These are ESM v21.
+Requires Screenplay 4.172.0 (`screenplay --version`) for these constructs; older compilers report PLAY0268.
+Sequence and generated secrets remain refused.
+
+Generated-concept rules select v20 (older compilers refuse them with PLAY0268): Proven silent, Refuted PLAY0688 plus witness, Unproven PLAY0689
+plus reason. Finite support exhaustion is PLAY0691, empty support on a scanned
+date PLAY0692, not a proof warning. MCP rules[]/derivedPattern support typed
+matches/PLAY0688 repair proposals.
+Requires Screenplay 4.173.0 for those MCP fields; older servers omit them.
+See [generation example](generation-strategies-example.md).
+
+Pin whole identifiers with `for`, other values with named `generated`; pins obey
+shape and rules. `given clock` fixes all UTC pattern date segments, not randomness;
+without it only digit widths are checked. Patterns are not gapless sequences or
+secrets; check digits catch typos, not forgery. Short payload codes need uniqueness,
+generated source destinations need freshness. Read
+[Stage admission](../../cratis-stage-rendering-and-sandbox/references/admission.md)
+for v21 admission, all-Proven unpinned specs and the separate prerequisites for
+warning/info rules, checksum validation and pattern/random rendering.
+`generate rule` remains STAGE-ESM-028. Reference binding is not rendering.
+
 ## Specification forms
 Full list with semantics: `Documentation/screenplay/specifications.md`. Compiled in the
 examples: `given caller` (+`authenticated`, `role`), `given clock`, `given <Event> for`,

package/package/corpus/skills/cratis-screenplay-toolchain/references/diagnostic-arguments.md

@@ -0,0 +1,60 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Read diagnostic subjects from arguments
+
+Requires Screenplay 4.194.0 or later (`screenplay --version`) for typed diagnostic arguments; older diagnostics may omit the field.
+
+Use code plus declared `arguments` to identify subjects, never parse message text.
+Messages are display prose and may be reworded. Published names, kinds, meanings
+and optionality are permanent; tolerate unknown names and keyword values.
+Missing `arguments` remains readable; no subjects is `{}`; optional subjects are
+omitted when unavailable. This changes neither text output nor ESM version.
+
+The `screenplay` MCP server's `diagnostics`, `read-workspace` executable diagnostics,
+proposal `diagnostics` and `introducedExecutableErrors[].arguments`, plus the CLI's
+JSON output, expose the same structure. Resolve the harness-native tool name from
+the listing; this is not a new diagnostic tool. C# exposes Diagnostic.Arguments.
+
+```json
+{
+  "specification": { "kind": "specification", "path": ["Billing", "Invoices", "SendReminder", "Overdue"] },
+  "step": { "kind": "keyword", "value": "when" },
+  "stepIndex": { "kind": "index", "value": 0 },
+  "property": { "kind": "text", "value": "amount" }
+}
+```
+
+Each argument is keyed by name. `text` is verbatim authored text, `keyword` a stable
+never-localized language spelling, `index` a zero-based number. A declaration uses
+its declaration kind as `kind` (for example `specification`) and `path`, not a
+`value`: module if present, features outermost first, slice if present, declaration
+name; never repeat a slice's own name. Specification names are authored names;
+a separate `case` names an expansion. Argument order is immaterial.
+
+## Codes with declared subjects
+
+`?` denotes optional. Except where marked, arguments are text.
+
+| Code | Arguments |
+| --- | --- |
+| PLAY0044, PLAY0075, PLAY0101, PLAY0518 | `text` |
+| PLAY0351 | `readmodel`, `property` |
+| PLAY0468 | `query?`, `argument` |
+| PLAY0514, PLAY0519 | `property` |
+| PLAY0520 | `example`, `type?`, `kind?` (keyword: event, command, readmodel, concept, type, example) |
+| PLAY0521 | `example` |
+| PLAY0522 | `example`, `kind`, `expectedKind` (both keyword: event, command, readmodel) |
+| PLAY0523 | `example`, `type`, `property?` |
+| PLAY0524 | `specification` (declaration), `step` (keyword), `stepIndex` (index), `property`, `type`, `example?`, `case?`, `parameter?` |
+| PLAY0525, PLAY0526 | `example` |
+| PLAY0583 | `case?`, `parameter?`, `type?`, `text?` |
+
+For PLAY0524, `step` is given, given readmodel, when, when append or then.
+`stepIndex` counts every authored given/when/then clause once across all forms,
+not nested lines, synthesized callers or defaults. Example/case expansion retains
+that position. Read the missing property and its type directly, navigate the
+specification path and optional case, then repair the effective fixture; do not
+infer these from a translated message. Codes outside this table may have no
+subjects, including PLAY0198. Check the published contract for the code rather
+than assuming every diagnostic names a declaration.