@cratis/pi 7.75.0 → 7.76.0

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" }
   ]
 }

package/package/corpus/skills/cratis-stage-rendering-and-sandbox/SKILL.md

@@ -11,9 +11,8 @@ ships a **renderer** (a .NET library, driven from a terminal by `cratis render`)
 disposable **sandbox** container (`cratis/stage`, started by `cratis run`) and a
 **specification runner** container (`cratis/stage-specrunner`).
 
-The admitted model shape is deliberately small. A model Stage cannot render exactly
-produces **no artifacts at all**, never thinner ones. Render the model to find out
-whether it is admitted; reading the admission rules is not a render result.
+A model Stage cannot render exactly produces **no artifacts**, never thinner ones.
+Probe the model; admission rules are not a render result.
 
 Requires cratis CLI ≥ 3.57 (`cratis --version`) to render ESM v14 and v15 models; an older CLI refuses newer ESM versions with `CLI-RENDER-004` (or `STAGE-ESM-016` from Stage directly).
 
@@ -22,9 +21,9 @@ Requires Cratis CLI 3.74.0 to render ESM v21–v26 models and 3.75.0 for v27; CL
 ## Batches, described handlers, text rules and protected reads
 
 Read [language admission](../cratis-screenplay-toolchain/references/language-admission.md)
-for v22–v25: text rules render, atomic batches/protected reads/described bodies do
-not. The semantic Host and specification runner execute admitted protected reads;
-that is not rendering. Stub mode emits no described-body stubs. Keep protection and report refusal.
+for v22–v25: text rules and admitted protected reads render; atomic batches and
+described bodies do not. Semantic execution is separate from rendering. Stub mode
+emits no described-body stubs. Keep protection and report refusal.
 
 ## When to use
 
@@ -73,12 +72,15 @@ Order: recover any interrupted publication, compile, bind, build the plan, plan
 Exit `0` is a published render, `5` is a refusal with nothing published (diagnostics are
 printed), `1` is a missing input. Add `-o json` for the counts and the publication receipt.
 
-Facts that surprise:
+Key facts:
 
 - **Binding uses the CLI's bundled compiler**, not the standalone one. Version admission
-  does not imply construct support: exact ESM v1–v21 and v23–v27 pairs are admitted,
-  while v22/v28 and mixed pairs refuse `STAGE-ESM-016`. Date/DateTime command comparisons (v26)
-  execute in the semantic Host and executor but refuse `STAGE-ESM-046` in the renderer. Pattern/random generation and checksum validation
+  does not imply construct support: exact ESM v1–v27 pairs are admitted;
+  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 still refuses `-043`.
+  Requires Stage 4.141.0 to render v26 Date/DateTime command comparisons; older
+  renderers refuse `-046`. Read [references/date-comparisons.md](references/date-comparisons.md)
+  when rendering dates for the remaining refusals and input-binding differences. Pattern/random generation and checksum validation
   render with an admitting renderer; `generate rule` renders in a new enough bundle (the Host and legacy syntax engine still refuse it with `STAGE-ESM-028`).
   Read [references/admission.md](references/admission.md) for the introducing-release
   prerequisites, all-Proven unpinned specifications and construct/pin checks (-011/-038).
@@ -116,7 +118,10 @@ modified stale artifacts. Recovery runs before planning:
 
 ## Admission
 
-One blocker publishes nothing. Codes, limits and fixes: [references/admission.md](references/admission.md).
+One blocker publishes nothing. Requires Stage 4.146.0 to collect independent admission
+refusals in one plan; older renderers stop at earlier batches of checks. Target-profile
+and unaudited-version refusals still stop first. Codes, limits and fixes:
+[references/admission.md](references/admission.md).
 
 - **Renders:** concepts/types/collections/optionals; portable StateChange and StateView slices,
   flat/scoped projections, pure reducers and reducer `from` filters; keyed optional snapshots,
@@ -139,11 +144,9 @@ One blocker publishes nothing. Codes, limits and fixes: [references/admission.md
   for ESM admission. Read the required typed `arguments.subject` for the command,
   never match message text. Requires Screenplay 4.210.0 (`screenplay --version`);
   older bundled binders use PLAY0268 for these handlers.
-- **Binding refusals (`PLAY0268`/`PLAY0271`):** legacy reads, `concurrency`,
-  context/single-result filters, opaque scope/performer, a list-query `by` block,
-  enum/identity compliance and subject lineage. Eligible protected reads bind v25;
-  pending handlers with unconditional productions bind v23, but neither renders. A read model with several key parts (v27) is admitted but refuses rendering (`STAGE-ESM-048`).
-  Never drop protection.
+- **Binding refusals:** read toolchain `references/executable-subset.md` for
+  `PLAY0268`/`PLAY0271` families; binding is not rendering. V27 keys are admitted
+  but refuse rendering (`STAGE-ESM-048`). Never drop protection.
 
 A refusal is not a licence to weaken the model: drop no specification, event generation or
 protection to get a render; keep the model, record the capability gap and gap-fill.
@@ -156,19 +159,15 @@ prose is not enforced. A documentation edit changes managed-file hashes (a `--ch
 Generated identities: read [shop strategy choices](references/choosing-generation.md) before
 rendering a model with generated values. Case tables and whole numbers:
 [case tables and whole numbers](references/case-tables-and-whole-numbers.md).
-`[ProtectedDecision]` and `DecisionRead<T>` are available to gap-fill code, not
-automatically emitted or protected by Stage; admission and unit-of-work enrollment still matter.
+Gap-fill `[ProtectedDecision]`/`DecisionRead<T>` use still needs admission and
+unit-of-work enrollment.
 
 ## What it emits
 
-At application scope the plan holds the scaffold plus the modeled artifacts: a `.csproj`
-and `.slnx`, `Program.cs`, `appsettings.json`, `docker-compose.yml`, the Directory props
-files, a policy registration and generated policies, `Common/<Concept>.cs`, one
-`<Module>/<Feature>/<Slice>/` folder per slice with the `[Command]` record and `Handle()`,
-the `[EventType]` event, the validator and the `[ReadModel]` with its query, `scene.json`,
-and a React/Vite frontend scaffold (`.frontend/`, `package.json`, `tsconfig.json`,
-`.gitignore`). Per-file detail, the scaffold's dependency set and the `Customizations/`
-contract, including the opt-in self-reducing layout for confirmed new Cratis C# applications:
+Application plans hold the backend scaffold, concepts, commands/events/validators,
+read models/queries and policies, plus Scene and React/Vite frontend artifacts.
+Read the per-file scaffold, dependency and `Customizations/` contract, including
+the opt-in self-reducing layout for confirmed new Cratis C# applications:
 [references/rendered-application.md](references/rendered-application.md). Scene
 package ids, host capabilities and the boundary from hand-built Components pages:
 [references/scene-runtime.md](references/scene-runtime.md). A complete renderable model:
@@ -193,36 +192,19 @@ Silent fallback to a default screen is a failure, not a partial render.
 
 ## Sandbox and specification runner
 
-`cratis run [PATH]` (Docker required) starts `cratis/stage` on the folder or file: Stage
-API on `9090`, Chronicle Workbench on `https://localhost:35000`. It is a **partial,
-disposable runtime**, not a generated application. `cratis run` runs the `semantic` engine
-(Requires Cratis CLI 3.73.0); Stage's semantic engine is the only engine going forward. The legacy
-EventModel engine (older CLIs, or the image without `Stage__Runtime__Engine=semantic`) is legacy; do not rely on it.
-It appends modeled
-`produces` facts and echoes the payload. It refuses missing required properties and
-simple literal `validate` rules on top-level properties, but enforces no other rule, no
-constraint and no command or query authorization; the semantic engine enforces them and
-refuses what it cannot execute (HTTP 501). The legacy engine
-also refuses routed models (`STAGE-ESM-030`), composite read-model keys (v27) and protected reads (`STAGE-ESM-044`); the semantic engine runs composite keys.
-Requires Cratis CLI 3.75.0 for `cratis run` to run v27 composite keys.
-Requires Stage 4.129.0 for semantic Host/runner protected reads; older engines refuse
-`STAGE-ESM-044`. Required absence rejects before requirements/generation, read properties
-feed requirements and productions, and non-Error protected requirements refuse
-`STAGE-ESM-045`, including reaction invocations. The Host faults on any outside append,
-even unrelated facts; this is stricter than reference dependency-scoped conflicts.
-Callers are built from unsigned headers, so
-authorization there is not a security boundary.
-
-`cratis/stage-specrunner` checks modeled specifications and writes a results file. The
-default `structural` engine is deprecated and model-level only; `--engine semantic`
-executes admitted specs through Arc's in-memory pipeline and reports `Passed`, `Failed`,
-`Unsupported` or `Cancelled`. A green result is Stage semantic-engine evidence: not V4 and
-not a rendered Debug test run. Commands, the report schema and limits:
-[references/sandbox-and-specrunner.md](references/sandbox-and-specrunner.md).
-
-Specification runner exit codes: `0` means the run completed and the results file was
-written **even when a specification failed**, so read the outcomes; `1` is a missing or
-uncompilable input; `2` a missing required argument or an invalid semantic option.
+`cratis run [PATH]` (Docker required) starts the disposable `cratis/stage`, not a
+generated application: API on `9090`, Workbench on `https://localhost:35000`.
+Requires Cratis CLI 3.73.0 for the semantic engine by default, 3.75.0 for v27 keys;
+older CLIs use the legacy EventModel engine, which does not enforce authorization.
+Unsigned caller headers make sandbox authorization no security boundary.
+Read [references/sandbox-and-specrunner.md](references/sandbox-and-specrunner.md)
+before running either image: engine selection, protected reads, outside-append
+conflicts/retries, reached bodies, authored occurrence and generated-spec limits live there.
+
+`cratis/stage-specrunner --engine semantic` reports `Passed`, `Failed`, `Unsupported`
+or `Cancelled`; deprecated structural mode is model-level only. Neither proves V4
+or rendered Debug tests. Exit `0` means the report was written **even on failed specs**:
+read outcomes. Exit `1` means missing/uncompilable input; `2` invalid arguments.
 
 ## Behavior walk (optional, after V3)
 

package/package/corpus/skills/cratis-stage-rendering-and-sandbox/references/admission.md

@@ -11,10 +11,10 @@
 - Specification rules (`STAGE-ESM-011`)
 - Refusals seen while drafting a model
 
-Stage admits exact ESM v1–v21 and v23–v27 language/semantic pairs, then checks
-constructs. V22, v28 and mixed or unknown pairs report `STAGE-ESM-016`. `cratis render` admits
-ESM v1–v27: Stage plans each model and refuses the constructs it cannot render with typed `STAGE-ESM-*`
-codes (a v22 model reports `STAGE-ESM-016`; v26 date comparisons report `STAGE-ESM-046`; v27 composite
+Stage admits exact ESM v1–v27 language/semantic pairs, then checks
+constructs. V28 and mixed or unknown pairs report `STAGE-ESM-016`. `cratis render` admits
+ESM v1–v27: Stage plans each model and refuses the constructs it cannot render with typed `STAGE-*`
+codes (atomic batches report `STAGE-ESM-043`; unsupported v26 date shapes `STAGE-ESM-046`; v27 composite
 read-model keys report `STAGE-ESM-048`/`-047`). The CLI refuses
 a bound model above v27 with `CLI-RENDER-004` before planning; a construct its bundled compiler cannot bind
 reports PLAY0268 instead.
@@ -38,15 +38,16 @@ opaque/unsupported rules refuse -005 before pin evaluation. Independent executio
 always needs pins.
 Requires Stage 4.124.0 for v24 text-rule admission (`cratis --version` identifies the CLI bundle); older renderers refuse v24 with STAGE-ESM-016.
 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 (`[ReadProtection(On)]`, a nullable read-model `Handle` parameter per read with `[LookUpBy]`, the `<View> '<key>' does not exist.` rejection, requirements evaluated in `Handle` after the reads; generated specifications run in decision mode); `cratis render` gets it from the first CLI that bundles Stage 4.138.0, and earlier bundles (CLI 3.75.0 bundles 4.137.0) refuse every protected read with STAGE-ESM-044. Reads it cannot preserve faithfully stay STAGE-ESM-044 and name the reason: constrained events, read paths in `produces when`, mappings to optional, collection, composite or mistyped event properties, generated-value freshness scopes. See [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
-Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines refuse STAGE-ESM-044. Required absence rejects before requirements or generation; read-backed requirements and produced-event mappings execute. Non-Error protected requirements refuse STAGE-ESM-045, including reaction invocations. See [sandbox boundaries](sandbox-and-specrunner.md#protected-command-reads) for ordering and the Host's stricter outside-append fault boundary.
+Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines refuse STAGE-ESM-044. Required absence rejects before requirements or generation; read-backed requirements and produced-event mappings execute. Non-Error protected requirements refuse STAGE-ESM-045, including reaction invocations. See [sandbox boundaries](sandbox-and-specrunner.md#protected-command-reads) for ordering and outside-append commit boundaries.
 Described handlers refuse STAGE-IMPL-002, even Stub mode; atomic mode in an
 admitted pair refuses STAGE-ESM-043. Version admission never implements a body,
 batch or composite-key rendering. Chronological Date/DateTime command comparisons
-select v26. The semantic Host and specification executor run them; the renderer,
-legacy engines and default sandbox engine refuse them with STAGE-ESM-046, naming the
-property, and emit no artifacts. Standalone reference success is not rendering. Keep
-the date rule and use authorized gap-fill rather than downgrading to ordinal text or
-millisecond precision.
+select v26. The semantic Host and specification executor run them.
+Requires Stage 4.139.0 for v22 admission; older Stage refuses v22 with -016.
+Requires Stage 4.141.0 for rendered date comparisons; older renderers and legacy
+engines refuse -046. Read [date comparisons](date-comparisons.md) when rendering
+v26 for the remaining -046 shapes and input-binding differences. Keep refused date
+rules; never downgrade to ordinal text or millisecond precision.
 
 Requires Stage 4.135.0 for v26 admission; older Stage refuses v26 with STAGE-ESM-016.
 
@@ -61,6 +62,13 @@ prerequisite. The exhaustive construct table is `references/renderable-subset.md
 One blocking diagnostic fails the **whole** plan and nothing is published (exit 5).
 Informational diagnostics (`PLAY0270` authoring metadata, `PLAY0469`, `STAGE-ESM-023`) do not.
 
+Requires Stage 4.146.0 for one plan collecting all independent version-feature,
+implementation-envelope, typed-context, event-lineage, slice, specification and Scene
+admission refusals; older renderers return earlier batches first. Duplicate refusals
+are listed once; refusals already collected survive an unexpected model shape.
+A target-profile mismatch or unaudited ESM version still stops before these checks.
+Classify the complete plan before editing; another probe is still required after fixes.
+
 A refusal can come from four layers, and the code tells you which: compilation and binding
 (`PLAY*`, from the CLI's bundled Screenplay), execution planning (`PLAN-*`), Stage
 admission (`STAGE-*`) and the CLI itself (`CLI-RENDER-*`). A publication conflict (a
@@ -149,13 +157,13 @@ Requires Stage 4.90.0 for snapshot/live lists, 4.96.0 for non-text secrets and 4
 | `STAGE-ESM-005` | Code validation or rule predicate bodies; or a command beyond the first capability (optional event property, event revision other than the first, validation or requirement that cannot be rendered, neither `produces` nor a response) | Use declarative validation; non-initial event generations are not rendered |
 | `STAGE-ESM-006` | `produces` that cannot render without changing its destination or mappings (expression/enum conditions, literal or computed mappings, `for` not a command identifier, mappings not one-to-one with event properties, duplicate tags) | Map properties one to one; supported conditional productions render as guarded events, not separate commands |
 | `STAGE-ESM-007`, `-008`, `-009` | Projection count per read model (exactly one projection or reducer each); unresolvable properties or no single read-model transition (**flat** projections only); affected instance not one, not keyed by an event property, or not the event-source identity (flat projections only) | One projection per read model; see "Projections" below |
-| `STAGE-ESM-010` | A query is neither an optional snapshot lookup by the read-model identifier nor a supported snapshot/observable collection query; each query is checked on its own. Both collection modes render. Concept-typed keys and filters retain Arc validation, including composite members and collection elements; nullable concept keys or optional concept filters with `not empty` cannot preserve null semantics | Keyed `XById => X optional` queries or snapshot/observable lists. Equality filters render on both collections; DateTime filters, required filters after optional ones and unsupported null-validation shapes refuse 010. Filter-name collisions refuse 012. Context/single-result filters, opaque scope/performer and a list-query `by` block remain PLAY0268; a read model with several key parts (v27) refuses `STAGE-ESM-016` |
+| `STAGE-ESM-010` | A query is neither an optional snapshot lookup by the read-model identifier nor a supported snapshot/observable collection query; each query is checked on its own. Both collection modes render. Concept-typed keys and filters retain Arc validation, including composite members and collection elements; nullable concept keys or optional concept filters with `not empty` cannot preserve null semantics | Keyed `XById => X optional` queries or snapshot/observable lists. Equality filters render on both collections; DateTime filters, required filters after optional ones and unsupported null-validation shapes refuse 010. Filter-name collisions refuse 012. Context/single-result filters, opaque scope/performer and a list-query `by` block remain PLAY0268; a read model with several key parts (v27) refuses `STAGE-ESM-048` |
 | `STAGE-ESM-011` | A specification cannot render (see the rules below) | Reshape it only if the assertion keeps its meaning; otherwise keep the specification, record the gap, and gap-fill with the specification as the oracle. Never weaken or delete it to get a render |
 | `STAGE-ESM-012` | Generated C# names collide (properties, types, namespaces, constraints) | Rename |
 | `STAGE-ESM-013` | An event-context value other than `$context.occurred` mapped in `produces` | Map a command property when that preserves the meaning; otherwise gap-fill |
 | `STAGE-ESM-014` | A constraint Chronicle cannot reproduce (kind, scope, message; multi-claim in one command; optional or composite targets) | A different constraint is a requirement change for the model owner; otherwise gap-fill |
 | `STAGE-ESM-015` | Authorization Stage cannot render exactly: a role-claim URI, an opaque policy nested inside a condition, an unresolved or non-portable policy, no single identifier, an opaque-policy subject that is not text, Uuid, Date or DateTime (a restriction on opaque-policy subjects, separate from declarative claim targets), an unsupported claim artifact. Role-only, authenticated, opaque pure policies, claim conditions with Uuid, Date, DateTime or text targets (numeric and Boolean claim matches render as always false) and `not`/and/or render; roles are read through the identity's `RoleClaimType` | Reshape the policy to a portable condition; otherwise gap-fill |
-| `STAGE-ESM-016` | Model language/semantic pair is not admitted by the installed Stage; exact v1–v21 and v23–v27 pairs are admitted, v22/v28 and mixed pairs refused; older Stage also refuses the versions listed in the minimums above. A CLI bundle reports `CLI-RENDER-004` above its ceiling (v27 for CLI 3.75.0) first. v14 filters and v15 generation join v11 numbers, v12 enum numbers and v13 compliance as supported constructs, not blanket construct support | Not fixable by editing: the model needs a newer renderer. Keep the model, record the gap, gap-fill |
+| `STAGE-ESM-016` | Model language/semantic pair is not admitted by the installed Stage; exact v1–v27 pairs are admitted, v28 and mixed pairs refused; older Stage also refuses the versions listed in the minimums above. A CLI bundle reports `CLI-RENDER-004` above its ceiling (v27 for CLI 3.75.0) first. v14 filters and v15 generation join v11 numbers, v12 enum numbers and v13 compliance as supported constructs, not blanket construct support | Not fixable by editing: the model needs a newer renderer. Keep the model, record the gap, gap-fill |
 | `STAGE-ESM-017` | Read model or projection cannot render (property names that collide with Chronicle paths or expression syntax, mappings that overwrite the key or child identity, composite keys, unsupported `all` mappings, the refused scope shapes below) | Reshape the projection without changing what it records, or record the gap |
 | `STAGE-ESM-018` | `$strings.` key missing in the default locale or containing formatting characters | Fix the strings |
 | `STAGE-ESM-019` | Reducer structure or body not admitted (outside a `StateView`, impure, does not compile), or a `generate rule` body that does not compile or produces a compiler warning | An equivalent pure body, or gap-fill |
@@ -179,9 +187,11 @@ Requires Stage 4.90.0 for snapshot/live lists, 4.96.0 for non-text secrets and 4
 | `STAGE-ESM-043` | `reaction batches atomic` in an admitted version pair | Keep the batch boundary; gap-fill without splitting it |
 | `STAGE-ESM-044` | A protected read the Cratis renderer cannot preserve faithfully, naming the reason (every protected read before Stage 4.138.0); the legacy Host/structural runner refuse the preamble | Keep protection; gap-fill the refused command; semantic Host/executor support is separate from generated-app enforcement |
 | `STAGE-ESM-047`, `-048` | ESM v27 composite read-model keys: `-048` read model with several key parts or projection keyed by parts (also the legacy syntax engine); `-047` single-instance query by parts | Keep the model; gap-fill the composite-keyed scope |
-| `STAGE-ESM-046` | Date/DateTime comparison in `require`, `produces when` or a validation rule (including through concepts) in the renderer, legacy engines or default sandbox engine; names the property | Keep the date rule; the semantic Host/executor run it; deliver rendering through gap-fill that compares exact calendar dates and UTC ticks |
+| `STAGE-ESM-046` | Compared DateTime concept with compliance or optionality, or a non-camel-case compared DateTime property; older renderers and legacy engines refuse all date comparisons | Keep the date rule and protection; see [date comparisons](date-comparisons.md) |
 | `STAGE-ESM-045` | Non-Error requirement on a protected command, including reaction-invoked commands; semantic admission refuses before reads, requirements or facts | Keep the severity contract; record the execution gap, never silently promote or drop the requirement |
 | `STAGE-IMPL-002` | Described command handler, naming command and RequirementId; also refused in Stub mode | Supply authorized implementation outside rendering; no generated stub is emitted |
+| `STAGE-IMPL-003` | Semantic Host/executor reaches a reducer or command/concept validation body; names owner and RequirementId (Requires Stage 4.145.0; older engines refuse unrelated behavior too) | Keep the body; run unaffected scope separately and gap-fill reached behavior. Renderer admission is unchanged |
+| `STAGE-PROFILE-001` to `-006` | Profile input cannot be honored: unknown package, missing layout, incompatible packages, missing theme, invalid root template or unresolved blueprint template | Fix the named input without substituting a different shell. Requires Stage 4.143.0 for shared `CratisRendering.ResolveProfileInputs(scene, approvedPackages)` findings; older consumers may have CLI-only checks |
 | `STAGE-ESM-037` | Events and commands from one handler, even across separate triggers on the same event in one reaction. The scaffold's Arc supports mixed results, but appends events before commands; a refused command causes redelivery and duplicate events | **Do not split the modeled reaction or drop an effect.** Gap-fill only with a proven retry-safe implementation; `[OnceOnly]` excludes replay, not retry |
 | `STAGE-ESM-023` | Information: transition bodies analysed | none |
 | `STAGE-CRATIS-001` to `-005` | Profile or `scene.json` not the package-owned shape; unrecognized or missing scaffold input; artifact path collision (`-004`, for example case names that normalize to one path); a modeled module or feature that would render into the reserved `Customizations/` (`-005`) | Rename the module, feature or case |