@cratis/pi 7.75.0 → 7.77.0

package/package/corpus/skills/cratis-screenplay-projections/references/pdl-grammar.md

@@ -5,6 +5,8 @@
 - Grammar
 - Parser regexes
 - Diagnostics
+- Event scope
+- Projection-level directives
 - Syntax that parses but means something else
 - Flat composite read-model keys
 - Worked examples
@@ -147,20 +149,53 @@ LiteralKeyword  = "literal", " ", Literal ;   (* parsed at the Expr level *)
 | `PLAY0191` | A read model is built by more than one projection or reducer |
 | `PLAY0192` | A read model is declared more than once |
 | `PLAY0295`–`PLAY0299` | An `$eventContext` path the event-context catalog does not have; `PLAY0299` also warns when a dynamic dictionary key uses a `$` source other than `$eventContext` |
-| `PLAY0380` | Chronicle drops part of a construct: `all` below the top level, or `automap` on a joined event |
+| `PLAY0380` | Only `all` inside `children`/`nested`: loses its subscription to every event type and behaves as `every` |
 | `PLAY0381` | A projection-level `key` routes no event |
 | `PLAY0382`–`PLAY0385` | Variant errors: no `enters on`, shared mapping missing on a variant, duplicate variant name, entering event claimed twice |
 | `PLAY0397` | Inline code uses a language line instead of a tagged fence |
 | `PLAY0398` / `PLAY0399` | A reducer mixes bodied and body-less rules / observes one event twice |
 
+## Event scope
+
+Requires Screenplay 4.212.3 (`screenplay --version`) for the ordinary compilation
+error `PLAY0801` (`DuplicateEventInProjectionScope`) in both compilers; older
+executable binding rejected duplicate uses later with `PLAY0273`.
+
+A level is the projection root, one `children` block, one `nested` block or one
+variant. Within that level, `from` (including each event in `from A, B` lists),
+`remove with`, `remove via join` and `clear with` share one set of event names.
+All `join` events at that level share a separate set: an event may occur once in
+`from` and once in a join, but not twice in either set. Each children, nested and
+variant block starts fresh sets; separate projections are independent.
+
+The check compares authored event names ordinally, without resolving
+qualifications or generations. It reports the second and each later reference;
+identical or different keys do not change the rule. One event cannot update two
+rows of the same level through two `from` blocks with different keys. Combine
+mappings for the same row into one block. Only a genuinely second domain fact
+warrants another event; never invent events only to satisfy the read side.
+These scope checks do not establish executable or renderer admission.
+
+## Projection-level directives
+
+`description "..."` (or a fenced text block) on the projection header (report-only `PLAY0270`; variants
+and nested blocks take none), `no automap`, `sequence <name>`, `file <path>`. `sequence` is a realization
+concern and does not bind to the executable model. A mapping target may end in a dynamic dictionary
+key, `count eventCountByType.$eventContext.eventType.id` (one entry per distinct value); only
+`$eventContext` resolves there, any other `$` text is a literal key with warning `PLAY0299`.
+
 ## Syntax that parses but means something else
 
+An `automap` / `no automap` under a joined event (`with …`) is honored for that
+event alone; without one, it follows its level's auto-map. Requires Screenplay
+4.212.4 (`screenplay --version`) for executable binding; older binders replace the
+joined event's setting with the level's. It does not report `PLAY0380`.
+
 | Syntax | What Chronicle and the executable model do |
 | --- | --- |
 | `key` on the projection | Nothing: events route by the `from` key, then the event source id (`PLAY0381`) |
 | `from X` with no key | Routes by the event source id, never by another `from`'s key |
 | `join … on …` | Updates existing instances only; never creates one; the name after `join` is discarded |
-| `automap` under a joined event | Replaced by the auto-map of the join's level (`PLAY0380`) |
 | `all` inside `children`/`nested` | Behaves as `every` (`PLAY0380`) |
 | `$causedBy.<x>` | Does not bind; use `$eventContext.causedBy.<x>` |
 | Templates in mappings or keys | Do not bind |

package/package/corpus/skills/cratis-screenplay-projections/verification.json

@@ -9,7 +9,18 @@
     { "kind": "skill-contains", "value": "Look first for the project's existing `.play` files" },
     { "kind": "skill-contains", "value": "`cratis ai install` manages `.cratis/ai/`, never model files" },
     { "kind": "skill-contains", "value": "AutoMap is on by default" },
+    { "kind": "skill-contains", "value": "decides auto-mapping for that event alone" },
+    { "kind": "skill-contains", "value": "without one, the joined event follows its level's auto-map" },
+    { "kind": "skill-contains", "value": "Requires Screenplay 4.212.4" },
+    { "kind": "skill-contains", "value": "| `PLAY0380` | Only `all` inside `children`/`nested`:", "file": "references/pdl-grammar.md" },
+    { "kind": "skill-contains", "value": "It does not report `PLAY0380`.", "file": "references/pdl-grammar.md" },
     { "kind": "skill-contains", "value": "PLAY0191" },
+    { "kind": "skill-contains", "value": "One event type is used once per projection level (`PLAY0801`)" },
+    { "kind": "skill-contains", "value": "cannot update two rows at that level, even with different keys" },
+    { "kind": "skill-contains", "value": "events only to satisfy the read side" },
+    { "kind": "skill-contains", "value": "`clear with` share one set of event names", "file": "references/pdl-grammar.md" },
+    { "kind": "skill-contains", "value": "Each children, nested and\nvariant block starts fresh sets", "file": "references/pdl-grammar.md" },
+    { "kind": "skill-contains", "value": "older\nexecutable binding rejected duplicate uses later with `PLAY0273`", "file": "references/pdl-grammar.md" },
     { "kind": "skill-contains", "value": "every event type in the system" },
     { "kind": "skill-contains", "value": "references/pdl-grammar.md" },
     { "kind": "skill-contains", "value": "Do not write `key` on the projection." },

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

@@ -36,24 +36,21 @@ Tool versions are covered in `cratis-screenplay-toolchain` `SKILL.md`; read it b
 
 Read [language admission](../cratis-screenplay-toolchain/references/language-admission.md)
 for v22–v25: Stage rendering refuses atomic batches, described bodies (even Stub mode)
-and protected reads. Semantic Host/executor support is not generated-app protection.
+but renders admitted protected reads in a supporting bundle. Semantic Host/executor
+support is not generated-app protection.
 Preserve contracts; reference success is not target realization.
 
-File/inline command handlers refuse PLAY0800 (`CommandHandlerRequiresAttachment`):
-a permanent requirement for a constrained implementation attachment. Gap-fill the
-slice in code rather than wait for a new ESM version. Hosts identify the command
-through the required typed `arguments.subject`, not message text. Requires
-Screenplay 4.210.0 (`screenplay --version`); older binders use PLAY0268 for these
-handlers. Other PLAY0268 families still mean not representable in a supported ESM
-version yet; triage details: [renderability gate](references/renderability-gate.md).
+File/inline command handlers permanently require constrained attachments: gap-fill
+in code, not by waiting for ESM admission. Requires Screenplay 4.210.0
+(`screenplay --version`) for PLAY0800 and required typed `arguments.subject`;
+older binders use PLAY0268. Read [renderability gate](references/renderability-gate.md)
+when classifying a handler or other binding refusal; never parse message text.
 
 ## Interview phase
-**Skip if** the request names the model root, the application name, the destination and the
-decision on non-renderable scope. Otherwise ask only what is missing:
-Ask only what is missing: the model and accepted version, the application name for `--name` (identical on every re-render), the destination, the decision if admission fails (the three cases below), and the seams (`Customizations/`). Read [references/delivery-protocol.md](references/delivery-protocol.md) ("Interview batch for render delivery") for the defaults.
-
-Unattended: assume visibly (probe destination, default name from the model root folder), never
-assume an answer to 4, and record it as `blocked` for the user.
+Ask only for missing inputs: accepted model/root, stable `--name`, destination,
+non-renderable-scope decision and seams. Read [references/delivery-protocol.md](references/delivery-protocol.md)
+when selecting defaults. Unattended, state probe-name/destination assumptions;
+never assume the non-renderable-scope decision: record it as blocked.
 
 ## The three cases (decide first, say which one applies)
 
@@ -63,36 +60,33 @@ assume an answer to 4, and record it as `blocked` for the user.
 | **B. Generated base plus authorized gap-fill** | an admitted render (whole, or a `--scope` of the admitted slices) exists and the user separately authorized hand-written scope, or a seam the model names needs an adapter | the generated output stays managed and untouched; hand-written code lives in `Customizations/` or a separate project (seam adapters by this skill, business gap-fill by `slice-implementer`), serves named model elements only, never claims render admission, and V5 is reported for the generated base **with its scope stated** |
 | **C. Fully hand-written delivery** | the scope cannot render and no generated base is wanted | `slice-implementer` delivers it with the model as the contract (`references/gap-fill-handoff.md`); V5 is `not run: no render` |
 
-Evolved events are gap-fill too: Stage still refuses any evolved event and its dependent scope with `STAGE-ESM-026`, because it cannot render Chronicle event-type migrations yet (Stage#204). Events at their initial revision still render. Hand-write the evolved events and their migrations per `cratis-chronicle-event-type-migration`, with the model as the contract.
+Evolved events and dependent scope refuse `STAGE-ESM-026`; initial revisions render.
+Gap-fill migrations per `cratis-chronicle-event-type-migration`, preserving the model contract.
 
-Supported UUID/String generation strategies, v15 freshness and scalar/named `returns`
-responses, fixtures and `then returns` render with the CLI and Stage. Unsupported generated
+Supported UUID/String generation, v15 freshness, responses, fixtures and
+`then returns` render. Unsupported generated
 types (`STAGE-ESM-028`) and result combinations (`-038`) still require case A or C:
 preserve the model and its specifications. See Stage's `references/admission.md`.
 Supported event-triggered Automation slices also render as managed Chronicle reactors;
-refused reactions, captures and Translate slices remain gap-fill.
-
-Models with event sources, streams or command routes bind and reference-execute as ESM v8 on the standalone
-tool, so report V3 and V4 from that tool. The CLI/Stage pair
-(`cratis-screenplay-toolchain/references/renderable-subset.md`) reaches v8 route checks
-and construct admission through v27 (Requires Cratis CLI 3.75.0; older bundles stop earlier, v28 is `CLI-RENDER-004`). Public/foreign events and production overrides
-still refuse; semantic reaction/reducer filters and role/authenticated `runs as` render.
-Claim-reading/opaque system gates, legacy actor/filter paths and mixed effects still refuse. Keep refused scope as case A/C,
-never infer target support from binding. Read Stage's `references/admission.md` and
-toolchain `references/sources-and-streams.md`.
-
-**Mixed reaction effects.** A reaction that both `produces` events and `invokes` commands is refused by
-Stage (`STAGE-ESM-037`) although Arc runs one reactor returning events
-and commands (events appended first as one batch, then commands in order, no cross-effect
-transaction; a retry can repeat the events). The scaffold now includes the mixed-result handler,
-but Stage still refuses it because redelivery can duplicate events. `[OnceOnly]` excludes replay,
-not retries. Keep the modeled reaction whole; gap-fill needs a proven retry-safe realization,
-not splitting or dropping effects to get a render. Source: Stage
-`Documentation/reference/reaction-rendering.md`.
-
-Read Stage's `references/admission.md` when checking v17/v19 or query validation:
-primitive query arguments still answer absence, not Screenplay's Validation.
-Query errors need v18 admission; do not delete rules or claim parity.
+refused reactions, captures and Translate slices remain gap-fill. A `given clock` fixture
+in the semantic executor is not support for rendering clock triggers.
+Requires Stage 4.141.0 to render v26 Date/DateTime command comparisons; older renderers
+refuse `STAGE-ESM-046`. Read [rendered date comparisons](../cratis-stage-rendering-and-sandbox/references/date-comparisons.md)
+when delivering dates for remaining refusals and input-binding differences.
+
+Source/stream routes bind and reference-execute as v8; target admission is separate.
+Requires Cratis CLI 3.75.0 for v27 admission; older bundles stop earlier, v28 is
+`CLI-RENDER-004`. Read toolchain `references/renderable-subset.md` and
+`references/sources-and-streams.md` when delivering routes, actor gates or filters.
+Preserve refused public/foreign events, production overrides and opaque gates as A/C.
+
+**Mixed effects (`STAGE-ESM-037`).** Keep the reaction whole: returned events append
+before commands and redelivery can duplicate them. `[OnceOnly]` excludes replay,
+not retries. Read Stage's [admission](../cratis-stage-rendering-and-sandbox/references/admission.md)
+when gap-filling a mixed reaction; prove retry safety, never split or drop effects.
+
+Read Stage's `references/admission.md` when checking v17/v19 or query validation;
+query errors need v18 admission. Preserve rules and test rejection separately from absence.
 
 Two rules hold in every case: a customization never makes a rejected model renderable, and
 a whole-application V5 is never claimed from a subset. `--scope` renders an admitted part (the whole
@@ -114,6 +108,9 @@ model still compiles and binds) and its V5 states the scope.
    (repeatable) to render an admitted part. Classify every
    diagnostic with `references/renderability-gate.md`: model fix in the chosen mode,
    capability gap, permanent implementation-attachment requirement, tool skew or environment. Group by code and count; do not paste the list.
+   Requires Stage 4.146.0 for collecting independent admission refusals in one plan;
+   earlier renderers reveal later batches after earlier fixes. Profile/version failures
+   still stop first. Classify all returned refusals before the next probe.
 3. **When admission fails** (case A) present the options, the user decides:
    (a) keep design mode and record the gaps; (b) narrow to renderable mode, where the modeler
    changes the model for business reasons and **without** removing protection (`pii`,

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

@@ -107,8 +107,9 @@ 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–v27 (STAGE-ESM-043); the declaration is not external-effect deduplication.
+invoked commands independent. Atomic mode refuses STAGE-ESM-043.
+Requires Stage 4.139.0 for v22 admission; older Stage reports -016.
+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
 render from Stage 4.138.0 (STAGE-ESM-044 from older bundles, or for shapes it cannot

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

@@ -35,7 +35,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 a list-query `by` block remain PLAY0268; a read model with several key parts or a projection keyed by parts (v27) refuses `STAGE-ESM-048` and a single-instance query by parts `STAGE-ESM-047` (Chronicle#4265); 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 reads the renderer cannot preserve, or any protected read in an older CLI bundle (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`); described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v27) | 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 or a projection keyed by parts (v27) refuses `STAGE-ESM-048` and a single-instance query by parts `STAGE-ESM-047` (Chronicle#4265); 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 reads the renderer cannot preserve, or any protected read in an older CLI bundle (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`); described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-043; v22 admission Requires Stage 4.139.0, older Stage reports -016) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
 | **Implementation attachment** | a permanent limitation, not future ESM admission | file/inline command handlers (PLAY0800; typed `subject` names the command) | keep the model contract and gap-fill the slice in code with a constrained implementation attachment; do not wait for a new ESM version |
 | **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-render-and-gap-fill/verification.json

@@ -38,13 +38,15 @@
     },
     {
       "kind": "skill-contains",
-      "value": "Keep refused scope as case A/C"
+      "value": "Preserve refused public/foreign events, production overrides and opaque gates as A/C"
     },
     {
       "kind": "skill-contains",
       "value": "STAGE-ESM-026"
     },
-    { "kind": "skill-contains", "value": "render with the CLI and Stage" },
+    { "kind": "skill-contains", "value": "`then returns` render" },
+    { "kind": "skill-contains", "value": "Requires Stage 4.141.0" },
+    { "kind": "skill-contains", "value": "Requires Stage 4.146.0" },
     { "kind": "skill-contains", "value": "Unsupported generated\ntypes (`STAGE-ESM-028`) and result combinations (`-038`)" },
     { "kind": "skill-contains", "value": "authored-UI parity" },
     { "kind": "skill-contains", "value": "responsible tool version" }

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/coverage-matrix.md

@@ -11,6 +11,15 @@
 Write it **before** drafting specs, keep it in `.ai-work/screenplay/<model-slug>/coverage.md` (or the
 `STATE.md` beside it), and update it with the specs. Reviewers check it against the model. Screenplay 4.127.0 MCP `find-specification-obligations` seeds the inventory (SPEC001–SPEC008), for command success, requirements, command/concept validation, effective authorization gates, value constraints, read models, projection removals and reaction outcomes. A met row proves matching authored presence, not full coverage or passing execution: the matrix still records domain judgments and scenario types the heuristic cannot infer.
 
+For SPEC004, a gated query's denial can use `when query <Query>` with
+`then denied`, or no `when` and exactly one `then query <Query>` with `arguments`
+and no `result`, followed by `then denied`. The read-only form meets that query's
+denial obligation, not the returned read model's SPEC006 assertion obligation.
+Keep a separate view state, absence or query-result specification.
+Requires Screenplay 4.212.2 (`screenplay --version`) for this inventory matching;
+older servers miss the read-only denial for SPEC004 and count it for SPEC006.
+Upgrade before gating on those rows; a met denial still proves presence, not execution.
+
 ## Cell values
 - `spec <Name>` - written; the name exists in the model.
 - `n/a: <domain reason>` - the situation cannot occur in this business. "Keeps it short" is not

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

@@ -8,9 +8,8 @@ license: MIT
 
 Read [preferred syntax](references/preferred-syntax.md) when writing or reviewing `.play`.
 
-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.
+This skill owns tool selection, verdicts and admission. Modeling method lives in
+`cratis-screenplay-modeling-lifecycle`; syntax lives in the construct skills.
 
 ## Locate the model
 
@@ -90,14 +89,12 @@ Independent results, not a ladder. Read `references/verdicts.md` for the command
 | V4 | reference specifications run | `screenplay test` or MCP `run-specifications`; unsupported/unbound is not a pass; rendered Debug tests are V5.tests, never V4 |
 | V5 | rendered and target-verified | `cratis render`, then Debug build and tests; report admission, publication, build and tests separately |
 
-V2 and V3 need MCP (V3 alone can also be read from `cratis screenplay validate --executable <root>`, labeled as the bundled compiler): send `initialize`, then `notifications/initialized`, and start the
-server with a fixed root. A subagent without MCP reports "V2 not run: no MCP in this agent".
-
-One line per verdict, tool first, for example `V1 pass (screenplay <version>, 3 files)` and
-`V3 blocked: PLAY0268 x3 (context filter, enum compliance)`. Name the source identity (commit plus the digest from
-the source-identity helper (`cratis-screenplay-modeling-lifecycle` `references/verdicts-and-modes.md` "Source identity")) the verdict ran on; keep it apart from the MCP
-`modelRevision`, which is semantic and, without `.screenplay/identities.json`,
-changes with the root folder name.
+V2 needs MCP; V3 also supports `cratis screenplay validate --executable <root>`
+(labeled as the bundled compiler). Read [verdict commands](references/verdicts.md)
+for MCP initialization, source identity and reporting. Without MCP, report
+`V2 not run: no MCP in this agent`. Report each verdict separately with tool,
+version, source identity and any blocking codes; MCP `modelRevision` is semantic,
+not the source identity.
 
 ## Subsets (write from the one your mode needs)
 
@@ -163,25 +160,11 @@ changes with the root folder name.
 
 ## Edit strategy
 
-- **Discover the capabilities available** (tool, version, `tools/list`, model root) once,
-  then prefer typed, identity-preserving MCP operations (`propose-ast`, `propose-rename`,
-  `propose-repair`, `propose-extract-inline-event`).
-- **Bounded text edits** are for edits that leave catalog addresses unchanged (descriptions,
-  rule and expression bodies, mappings between existing members): a small `.play` diff
-  followed by V1. Without `.screenplay/identities.json`, plain text edits are fine. Never use a
-  text edit to get around an MCP refusal.
-- **Catalog-changing edits** belong to the identity owner (the session that owns MCP). When
-  `.screenplay/identities.json` exists, adding, removing or renaming an addressed element
-  (declarations, properties of commands, events, read models, composite types and triggers,
-  queries, query arguments, specifications), moving declarations, creating, deleting, renaming
-  or moving a mapped `.play` document (`IdentityMappingConflict`) and persisted event contract
-  evolution go through MCP, and `id` pins alone
-  are not enough: a session without MCP returns the request to the owning session.
-- AST JSON costs several times the text it replaces; use it where a typed operation is the
-  only identity-safe route.
-- Proposals are connection-local (at most 16); `apply` writes `.screenplay/identities.json`
-  and is not crash-atomic; never retry `apply` after `ApplyOutcomeUnknown`. Loop details:
-  `cratis-screenplay-model-authoring`.
+Read [the MCP authoring loop](../cratis-screenplay-model-authoring/references/mcp-loop.md)
+when editing: the identity owner uses typed proposals for catalog-changing edits;
+text edits never bypass a refusal. Without MCP, return identity-affecting work
+to its owner. Proposals are connection-local; apply is not crash-atomic, and an
+unknown apply outcome requires recovery, not retry.
 
 ## Top traps
 

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

@@ -8,6 +8,7 @@
 - Explicit enum member numbers
 - Reserved stored names and event pins
 - Named keys, production routes and observer filters
+- Projection event scope (PLAY0801)
 - Reducer instance identity (PLAY0690)
 - Caller identity, compliance and routes
 - Specification metadata, callers, cases and locators
@@ -147,6 +148,25 @@ Overrides/filters select released ESM v10; malformed routes also use PLAY0504.
 Read read-surface `references/named-keys.md` and
 [production routes and filters](production-routes-and-filters.md).
 
+## Projection event scope (PLAY0801)
+
+Requires Screenplay 4.212.3 (`screenplay --version`) for this ordinary compilation
+check in both C# and TypeScript; older executable binding rejected these duplicate
+uses later with PLAY0273.
+
+| Code | Severity | Meaning / fix |
+| --- | --- | --- |
+| PLAY0801 | E | `DuplicateEventInProjectionScope`: an event name occurs more than once in one projection level's event set or separate join set. Reports the second and each later reference, even with identical or different keys. Combine same-row mappings into one block; one event cannot update two rows of that level through two `from` blocks. |
+
+A level is the root, one `children` block, one `nested` block or one variant.
+`from` (including each event in `from A, B` lists), `remove with`, `remove via join`
+and `clear with` share one set of event names. `join` events have their own set:
+once in `from` and once in a join is allowed. Each children, nested and variant
+block starts fresh sets; separate projections are independent. Names compare
+ordinally without resolving qualifications or generations. If the domain has a
+genuine second fact, model it as its own event; never invent events only to
+satisfy the read side. Full scope guidance: projections `references/pdl-grammar.md`.
+
 ## Reducer instance identity (PLAY0690)
 
 | Code | Severity | Meaning / fix |
@@ -299,6 +319,17 @@ as errors if gating. Ordinary compile success does not imply these ran:
 | purposes | PLAY0602–0606 | Personal-data coverage, special/criminal safeguards, basis and unused-purpose prompts; union of ancestor/direct references |
 | personas | PLAY0574–0576 | Unused personas, unreachable gates and ambiguous buildable policy alternatives; unsynthesizable/undecidable is unknown |
 
+For `query-keys` (PLAY0535), a collection `by` can match a same-named compatible
+read-model field or composite key part, or the identity. A single-result `by`
+still matches the identity, not an arbitrary field. Parameter optionality is
+ignored for compatibility; `optional` alone does not establish a match. Identity
+inference uses only single-result keyed queries, not collection queries, with
+structurally resolved projection keys as fallback. Performer-served views,
+tenant-context parameters and unknown identity types are skipped.
+Requires Screenplay 4.212.1 (`screenplay --version`) for this check alignment;
+older tools can warn on valid collection fields or optional parameters and infer
+identity from collection queries. Upgrade before using those warnings as a gate.
+
 Whole-source errors skip completeness checks. Unknown/opaque coverage is not
 invented: report skipped status/coverage and walk field lineage manually.
 
@@ -359,20 +390,22 @@ refusal reasons. Read [language admission](language-admission.md) before changin
 | 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–v27; retain declaration and gap-fill |
+| STAGE-ESM-043 | Atomic mode not realized in admitted v22–v27; retain declaration and gap-fill (v22 admission Requires Stage 4.139.0; older Stage reports -016) |
 | STAGE-ESM-047 | Single-instance query by composite key parts (v27) in the renderer, until Chronicle can look up composite keys (Chronicle#4265); keep the query, gap-fill |
 | STAGE-ESM-048 | Read model with several key parts, or projection keyed by parts (v27), in the renderer or legacy syntax engine; keep the model, gap-fill |
 | STAGE-ESM-044 | Renderer refuses a protected read despite v25 admission: any protected read in a bundle that predates protected-read rendering, afterwards only shapes it cannot preserve (constrained events, read paths in `produces when`, optional/collection/composite/mistyped mapping targets, freshness scopes), naming the reason; the legacy Host/structural runner refuse the preamble. Semantic Host/executor support is separate; keep protection and gap-fill generated-app scope |
 | STAGE-ESM-045 | Non-Error protected requirement; semantic Host/executor refuse before execution, including reaction-invoked commands; keep severity and report Unsupported |
 | STAGE-IMPL-002 | Described handler body not realized by Stage, even Stub mode; no stubs emitted |
+| STAGE-IMPL-003 | Reached reducer or command/concept validation body in semantic Host/executor; owner and RequirementId named, unrelated behavior remains admitted (Requires Stage 4.145.0; older engines refuse unrelated behavior too) |
+| STAGE-PROFILE-001 to -006 | Shared target profile-input findings: unknown package, missing layout, incompatible packages, missing theme, invalid root template, unresolved blueprint template (Requires Stage 4.143.0; older consumers may check only in the CLI) |
 
 Invalid match syntax remains PLAY0367. Property/concept text rules bind v24;
 `contains`/`starts with` in conditions only still fail PLAY0268. Stage rejects
-v22/v28 and mixed pairs with STAGE-ESM-016; v23–v27 admission does not implement
-bodies or batches, the renderer refuses protected reads it cannot preserve (STAGE-ESM-044; every
-protected read in an older bundle), v26 date comparisons (STAGE-ESM-046) and composite read-model
-keys (STAGE-ESM-048/-047). Read
-[language admission](language-admission.md) for the stricter Host outside-append guard.
+v28 and mixed pairs with STAGE-ESM-016; v1–v27 admission does not implement
+bodies or batches. The renderer refuses protected reads it cannot preserve (STAGE-ESM-044; every
+protected read in an older bundle), unsupported date-comparison shapes (STAGE-ESM-046;
+all date comparisons before Stage 4.141.0) and composite read-model keys (STAGE-ESM-048/-047).
+Read [language admission](language-admission.md) for Host outside-append commit behavior.
 Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines refuse -044.
 
 ## Binding (V2 and V3) - see `executable-subset.md` for the full table

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

@@ -266,8 +266,11 @@ DateTime input needs an offset or `Z`, else Validation rejects before rules, eve
 for skipped comparisons. `then` matching stays ordinal. Invalid date literals or
 offset-less DateTime literals in admitted comparisons report PLAY0273. Read
 [date comparisons](../../cratis-screenplay-command-surface/references/date-comparisons.md)
-for the complete window model and retained PLAY0268 refusals. The Stage renderer refuses
-v26 date comparisons with STAGE-ESM-046, independently of standalone binding/reference execution.
+for the complete window model and retained PLAY0268 refusals. Requires Stage 4.141.0
+for rendered date comparisons; older renderers refuse STAGE-ESM-046. Read
+[rendered dates](../../cratis-stage-rendering-and-sandbox/references/date-comparisons.md)
+when checking remaining refusals and input-binding differences. Standalone binding/reference
+execution is independent of rendering.
 
 ## Flat composite read-model keys (ESM v27)
 

package/package/corpus/skills/cratis-screenplay-toolchain/references/language-admission.md

@@ -9,11 +9,11 @@ exact language/semantic pairs; binding, reference execution and rendering are se
 
 | 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–v27 refused STAGE-ESM-043 |
+| v22 | Application-root `reaction batches atomic` | Direct productions per trigger occurrence and each selected refusal branch are separate atomic batches; commands remain independent | v22 admitted with a supporting bundle; atomic mode 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; Cratis renderer renders protected reads in a new enough bundle (STAGE-ESM-044 before it, and for shapes it cannot preserve); semantic Host/executor execute reads, non-Error protected requirements refuse STAGE-ESM-045 |
-| v26 | Chronological command Date/DateTime comparisons | Same-primitive `==`, `!=`, `>`, `>=`, `<`, `<=`; DateTime UTC ticks and pre-rule offset validation | v26 admitted; Host/executor run it, renderer and legacy engines refuse STAGE-ESM-046 |
+| v26 | Chronological command Date/DateTime comparisons | Same-primitive `==`, `!=`, `>`, `>=`, `<`, `<=`; DateTime UTC ticks and pre-rule offset validation | v26 admitted; Host/executor run it; renderer supports admitted shapes with remaining STAGE-ESM-046 refusals; legacy engines refuse -046 |
 | v27 | A read model with two or more `key` marks | Untyped projection `key` blocks, equality-filter lists, single-instance `by` blocks, per-part fixtures | v27 admitted; Host runs it, renderer refuses STAGE-ESM-048/-047, executor refuses specs over it |
 | v28 | `==`/`!=` between Uuid values in command `require` and `produces when` | Uuid properties, Uuid concepts and identities, canonical literals; protected read paths in `require` only | v28 refused STAGE-ESM-016 |
 
@@ -35,7 +35,7 @@ Requires Stage 4.124.0 for v24 text-rule admission (`cratis --version` identifie
 
 Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. Requires Stage 4.138.0 for the Cratis renderer to render protected reads as Arc read protection; earlier renderers, and reads it cannot preserve, refuse STAGE-ESM-044 and emit no artifacts. `cratis render` gets this from the first CLI that bundles Stage 4.138.0; CLI 3.75.0 bundles Stage 4.137.0.
 
-Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines refuse STAGE-ESM-044. Absence rejects before requirements/generation; read properties feed requirements and productions. Non-Error protected requirements refuse STAGE-ESM-045, including reaction invocations. Legacy Host/structural runner retain -044. The Host faults on any outside append, stricter than reference dependency-scoped conflicts; see [sandbox boundaries](../../cratis-stage-rendering-and-sandbox/references/sandbox-and-specrunner.md#protected-command-reads).
+Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines refuse STAGE-ESM-044. Absence rejects before requirements/generation; read properties feed requirements and productions. Non-Error protected requirements refuse STAGE-ESM-045, including reaction invocations. Legacy Host/structural runner retain -044. Requires Stage 4.142.0 for outside facts to participate in decide/commit, with unrelated appends absorbed; older Hosts fault on any outside append; see [sandbox boundaries](../../cratis-stage-rendering-and-sandbox/references/sandbox-and-specrunner.md#protected-command-reads).
 
 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
@@ -74,10 +74,20 @@ the same condition without Uuid operands keeps its earlier version. To see the s
 the model with the `screenplay` MCP server and call `read-workspace` with `view` `executable-model`:
 `languageVersion` reads `28.0`.
 
-Stage's semantic engines admit exact v1–v21 and v23–v27 pairs. V22/v28 and mixed
-pairs refuse STAGE-ESM-016. Admission of v23–v27 is not admission of described bodies,
+Stage's semantic engines admit exact v1–v27 pairs. V28 and mixed
+pairs refuse STAGE-ESM-016.
+Requires Stage 4.139.0 for v22; older Stage refuses -016.
+Admission is not admission of described bodies,
 atomic mode or composite-key rendering, and protected reads render only in a bundle that supports them. 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.
 
 Requires Stage 4.135.0 for v26 admission and 4.137.0 for v27; older Stage refuses them with STAGE-ESM-016.
+Requires Stage 4.141.0 to render date comparisons; older renderers refuse -046.
+Read [rendered dates](../../cratis-stage-rendering-and-sandbox/references/date-comparisons.md)
+when checking remaining -046 shapes and input-binding differences.
+Requires Stage 4.145.0 for reach-scoped reducer/validation-body refusals
+(STAGE-IMPL-003); older engines refuse unrelated behavior too. Described command
+handlers retain STAGE-IMPL-002; renderer implementation admission is unchanged.
+Read [sandbox boundaries](../../cratis-stage-rendering-and-sandbox/references/sandbox-and-specrunner.md)
+when a semantic run reaches a body or uses an authored reaction clock.

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

@@ -23,10 +23,13 @@ and concept compliance (v13) render.
 
 The language is frozen at ESM v1–v28 ([the freeze decision](https://github.com/Cratis/Screenplay/blob/main/decisions/0092-the-language-is-frozen-at-esm-v28.md)): no new versions, constructs, keywords or grammar, except a construct for a real model that is blocked with no model-side alternative, accepted in its own record. Model with what v1–v28 offers; when Stage, `cratis render` or Studio does not support a construct yet, treat the typed refusal as a platform gap to report, since consumers are catching up to v28, not a reason to wait for new language.
 
-Stage admits exact ESM v1–v21 and v23–v27 pairs; v22/v28 and mixed pairs
-refuse STAGE-ESM-016. Chronological command Date/DateTime comparisons select v26:
-the Host and executor run them, but the renderer refuses STAGE-ESM-046, so they are not renderable. Keep the
-rule and use authorized gap-fill. Version admission is separate from construct support.
+Stage admits exact ESM v1–v27 pairs; v28 and mixed pairs refuse STAGE-ESM-016.
+Requires Stage 4.139.0 for v22 admission; older Stage refuses v22 with -016,
+while atomic mode remains -043. Chronological command dates select v26.
+Requires Stage 4.141.0 to render Date/DateTime comparisons; older renderers refuse -046.
+Read [rendered dates](../../cratis-stage-rendering-and-sandbox/references/date-comparisons.md)
+when checking remaining -046 shapes and input-binding differences. Version admission
+is separate from construct support.
 Requires Stage 4.106.0 for v18 admission; older Stage refuses it with `STAGE-ESM-016`.
 For generated-concept v20/v21 admission and construct prerequisites, read
 [Stage admission](../../cratis-stage-rendering-and-sandbox/references/admission.md).

package/package/corpus/skills/cratis-screenplay-toolchain/references/screenplay-contract.json

@@ -33536,7 +33536,7 @@
       "severities": [
         "warning"
       ],
-      "title": "A projection construct binds, but Chronicle\u0027s projection lowering drops part of it: all inside a children or nested block loses its subscription to every event type, and an auto-map setting on a joined event is replaced by the level\u0027s.",
+      "title": "A projection construct binds, but Chronicle\u0027s projection lowering drops part of it: all inside a children or nested block loses its subscription to every event type.",
       "reserved": false,
       "retired": false
     },
@@ -37838,6 +37838,17 @@
           "meaning": "The command whose handler requires a constrained implementation attachment."
         }
       ]
+    },
+    {
+      "code": "PLAY0801",
+      "name": "DuplicateEventInProjectionScope",
+      "severity": "error",
+      "severities": [
+        "error"
+      ],
+      "title": "An event is used more than once in one projection level\u0027s event or join set.",
+      "reserved": false,
+      "retired": false
     }
   ],
   "mcpTools": [

package/package/corpus/skills/cratis-screenplay-toolchain/references/screenplay-contract.version

@@ -1 +1 @@
-4.211.1
+4.212.4

package/package/corpus/skills/cratis-screenplay-toolchain/verification.json

@@ -47,7 +47,7 @@
     { "kind": "skill-contains", "value": "XML doc comments" },
     { "kind": "skill-contains", "value": "cratis screenplay validate" },
     { "kind": "skill-contains", "value": "validating one file with `cratis screenplay validate file.play`", "file": "references/traps.md" },
-    { "kind": "skill-contains", "value": "`notifications/initialized`" },
+    { "kind": "skill-contains", "value": "`notifications/initialized`", "file": "references/verdicts.md" },
     { "kind": "skill-contains", "value": "Pending described handlers bind but do not execute their bodies" },
     { "kind": "skill-contains", "value": "STAGE-ESM-043", "file": "references/language-admission.md" },
     { "kind": "skill-contains", "value": "v25", "file": "references/language-admission.md" },
@@ -64,6 +64,13 @@
     { "kind": "skill-contains", "value": "RejectsAUsedGeneratedSource", "file": "references/generation-strategies-example.md" },
     { "kind": "skill-contains", "value": "bind as ESM v8" },
     { "kind": "skill-contains", "value": "PLAY0530/0531", "file": "references/diagnostics.md" },
-    { "kind": "skill-contains", "value": "Editor versus C# verdicts", "file": "references/diagnostics.md" }
+    { "kind": "skill-contains", "value": "Requires Screenplay 4.212.1", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "Identity\ninference uses only single-result keyed queries", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "Editor versus C# verdicts", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "PLAY0801 | E | `DuplicateEventInProjectionScope`", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "Requires Screenplay 4.212.3", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "`clear with` share one set of event names", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "`join` events have their own set", "file": "references/diagnostics.md" },
+    { "kind": "skill-contains", "value": "Each children, nested and variant\nblock starts fresh sets", "file": "references/diagnostics.md" }
   ]
 }