@cratis/pi 7.64.0 → 7.65.0

package/package/corpus/product-sync.json

@@ -46,7 +46,7 @@
         ],
         "rules": []
       },
-      "notes": "Source-checked Stage v4.103.0: exact ESM v1-v17 and v19, not v18 or v20 (v18 admitted from 4.106.0 and v20 from 4.109.0, taught with Requires lines; 4.104-4.108 not otherwise reviewed). Snapshot/live collection queries, identity-mapping all projections, stored event names, event-id publication checks, release-baseline warnings, command clock/receipt-time generation, conditional and multi-command slices, generated text constraints, no-event and bounded redelivery specs, refusal branches. Query concept validation still uses primitive workaround; Stage#370 released in 4.106.0. CLI v3.62.0 bundles Stage 4.99.0, not 4.103.0. Generated-values-only delta checked at v4.127.0: v21/all-Proven unpinned specs from 4.115.0, warning/info generated rules 4.117.0, checksum validation 4.118.0, pattern/random factories/Host/executor 4.119.0; generate rule still STAGE-ESM-028. Language admission reconciled at the same v4.127.0 tag: exact v1-v21 and v23-v25 pairs; v22/v26 and mixed pairs -016, protected reads -044, atomic mode -043, described bodies STAGE-IMPL-002 even Stub mode; v24 first admitted 4.124.0 (absent 4.123.0). Other deltas not reviewed; synced unchanged. No new render/browser/Docker probe."
+      "notes": "Source-checked Stage v4.103.0: exact ESM v1-v17 and v19, not v18 or v20 (v18 admitted from 4.106.0 and v20 from 4.109.0, taught with Requires lines; 4.104-4.108 not otherwise reviewed). Snapshot/live collection queries, identity-mapping all projections, stored event names, event-id publication checks, release-baseline warnings, command clock/receipt-time generation, conditional and multi-command slices, generated text constraints, no-event and bounded redelivery specs, refusal branches. Query concept validation still uses primitive workaround; Stage#370 released in 4.106.0. CLI v3.62.0 bundles Stage 4.99.0, not 4.103.0. Generated-values-only delta checked at v4.127.0: v21/all-Proven unpinned specs from 4.115.0, warning/info generated rules 4.117.0, checksum validation 4.118.0, pattern/random factories/Host/executor 4.119.0; generate rule still STAGE-ESM-028. Language admission reconciled at the same v4.127.0 tag: exact v1-v21 and v23-v25 pairs; v22/v26 and mixed pairs -016, protected reads -044, atomic mode -043, described bodies STAGE-IMPL-002 even Stub mode; v24 first admitted 4.124.0 (absent 4.123.0). Reviewed v4.128.0-v4.130.0 deltas for Cratis/AI#739: v4.128.0 new-application self-reducing Cratis C# profile (CreateNewApplicationProfile, ReducerConventionInput.Read, WithReducerConvention; existing callers classic); shared SemanticValidationRules.Check confirmed (already present in v4.127.1, so no new 4.128.0 minimum claimed); v4.129.0 semantic Host/executor protected reads, presence before requirements/generation, read-backed requirements/mappings, non-Error requirements STAGE-ESM-045 including reaction invocations, Host fault on any outside append (stricter than reference scoped conflict). Renderer/legacy Host/structural runner retain STAGE-ESM-044. v4.130.0 root-template shell, options/appearance and fail-closed startup/planning findings reviewed in stage-rendering.md, RootShell.cs and stageShell.ts. Exact pairs remain v1-v21 and v23-v25; v26 refused STAGE-ESM-016 and Stage#473 still open. Earlier unreviewed deltas remain as noted above, so synced stays at the last fully reviewed release. No new render/browser/Docker probe."
     },
     {
       "id": "arc",

package/package/corpus/skills/cratis-fundamentals-concept/references/shop-generation.md

@@ -74,9 +74,10 @@ has 74 random bits and the TypeID `order_` prefix. Default NanoID is 21 symbols
 with 126 bits; bytes use unpadded base64url (43 symbols for 32 bytes).
 
 `IGeneratableInContext<TSelf>` requires `static abstract TSelf New(GenerationContext)`.
-`GenerationContext` holds one captured `DateTimeOffset Now` and a portable String
-`Tenant`; `DefaultTenant` is the zero-GUID string, never a display name or empty
-string. The shop passes time and tenant together, for example:
+Fundamentals' `Cratis.Concepts.GenerationContext` is a readonly record struct with
+one captured `DateTimeOffset Now` and a String `Tenant`; `DefaultTenant` is the
+zero-GUID string, never a display name or empty string. The shop passes time and
+tenant together, for example:
 
 ```csharp excerpt
 var context = new GenerationContext(
@@ -91,6 +92,18 @@ A domain factory can read Tenant, but arbitrary tenant IDs cannot be inserted
 into a TypeID prefix (only lowercase letters/underscores, letter endpoints).
 Do not present a tenant-prefixed custom string as standard TypeID.
 
+For Screenplay `generate rule`, this Fundamentals type is the **Cratis C# target's**
+binding of the language-neutral Now/Tenant descriptor, not the universal runtime
+type. `Cratis.Screenplay.Contexts.GenerationContext` remains a BCL-only record with
+portable `TenantId Tenant`, not a Fundamentals alias. The selected provider, not
+`csharp` or a file reference, chooses the binding. Portable C# uses `context.Now`,
+BCL operations and tenant text (for example `$"{context.Tenant}"`, compared ordinally).
+Passing the whole context to `GenerateValue.*`, naming/constructing GenerationContext,
+using `DefaultTenant` or reading `Tenant.Value` is target-bound. Never add a bridge
+or claim Stage renders a rule merely because its Cratis binding is defined; read
+[generation context binding](../../cratis-screenplay-command-surface/references/generated-values-and-responses.md#generation-context-binding)
+for the compiler prerequisite and renderer refusal.
+
 Use the context form only for time/tenant-dependent generation. If both interfaces
 are implemented, callers choose context; the interfaces themselves do not dispatch.
 Time-ordered built-in context overloads reject default Now (`MissingGenerationTime`)

package/package/corpus/skills/cratis-screenplay-automations-and-translations/SKILL.md

@@ -171,7 +171,8 @@ or actor that nobody confirmed. Read `references/worked-integration.md` when you
   separate binder check.
 - A trigger with `reads` that `produces` directly fails binding: decide in a command.
   Command reads can protect with `command reads protected` and admitted shapes (v25);
-  trigger reads cannot. Stage refuses protected reads (STAGE-ESM-044); target protection remains a separate check.
+  trigger reads cannot. The Cratis C# renderer refuses protected reads (STAGE-ESM-044);
+  semantic execution is separate from generated-app protection.
 - An authorized command exercised in a spec without `given caller` is PLAY0389 at binding.
 - A list query (`=> Item[]`) binds (a snapshot list is not rendered, `STAGE-ESM-010`);
   a clock sweep that iterates items needs a code body the reference does not run

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/SKILL.md

@@ -104,7 +104,9 @@ binding, because its decision dependency cannot be protected. A reaction that on
 command's own reads. Eligible command reads protect under application-root
 `command reads protected` (ESM v25); legacy reads retain PLAY0271. Read command-surface
 [protected reads](../cratis-screenplay-command-surface/references/protected-reads.md)
-for admission and absence/conflict behavior. Stage admits v25 but refuses protected reads with STAGE-ESM-044.
+for admission and absence/conflict behavior. Stage admits v25; the Cratis C# renderer refuses protected reads with STAGE-ESM-044.
+Semantic Host/executor support is separate; non-Error protected requirements refuse -045,
+including reaction-invoked commands.
 `where` over read paths out of scope, and `where` needs
 every operand to resolve from the trigger's declared scalar occurrence shape (listed in
 the input selection or not; nested paths and read aliases fail binding): keep the logic that uses the state in

package/package/corpus/skills/cratis-screenplay-command-surface/SKILL.md

@@ -151,7 +151,8 @@ view name when that view is read once.
 Opt eligible state reads into application-root `command reads protected` (v25).
 Absence rejects; matching intervening facts conflict. Read [protected reads](references/protected-reads.md)
 for strict admission, paths and PLAY0780–0786. Legacy reads stay unprotected;
-reads/concurrency cannot combine (PLAY0783). Stage refuses protected reads (STAGE-ESM-044), not v25 itself.
+reads/concurrency cannot combine (PLAY0783). The Cratis C# renderer refuses protected reads (STAGE-ESM-044), not v25 itself;
+semantic Host/executor support is separate.
 Uniqueness still uses a constraint; reference success is not target realization.
 
 Do not use `reads` to fetch data the caller could supply. A composite-key view's `by` block is

package/package/corpus/skills/cratis-screenplay-command-surface/references/generated-values-and-responses.md

@@ -5,6 +5,7 @@
 - Choosing a strategy
 - When not to
 - The concept declares how; the property declares that
+- Generation context binding
 - Inspect and edit generation through MCP
 - Generated-concept rules (ESM v20)
 - Version and freshness
@@ -94,6 +95,35 @@ checks only suffix shape on fixtures. `generate sequence` stays reserved (PLAY06
 and compliance markers on generated concepts, including secrets, remain refused.
 Never remove classification to make a model bind.
 
+## Generation context binding
+
+Requires Screenplay 4.181.1 or later (`screenplay --version`) for per-target context
+binding and tenant value formatting; older context documentation does not establish
+that binding. The version-1 ValueGeneration descriptor is language-neutral: `Now`
+(an instant), portable `TenantId` `Tenant`, and a String result. The selected provider,
+not a `csharp` fence or file attachment, chooses the native context type.
+
+The Cratis C# target (Arc and Stage's Cratis target contract) binds it to Fundamentals'
+`Cratis.Concepts.GenerationContext` (`DateTimeOffset Now`, `string Tenant`). BCL-only
+hosts can use `Cratis.Screenplay.Contexts.GenerationContext` (`Now`, `TenantId Tenant`);
+that package stays BCL-only. The types are name-compatible, not type-identical.
+
+For portable C# bodies, use `context.Now`, BCL operations and the tenant as text:
+`$"{context.Tenant}:{context.Now:yyyyMMdd}"`. `TenantId` formats as its value;
+compare that formatted string ordinally when a tenant comparison is needed.
+Passing `context` to `GenerateValue.*`, naming `GenerationContext` or
+`GenerationContext.DefaultTenant`, constructing a context, or reading
+`context.Tenant.Value` is target-bound.
+
+For example, `generate rule TenantReceiptNew` can own the inline `csharp` body
+`return $"{context.Tenant}:{GenerateValue.Ulid(context)}";` on the Cratis C# binding.
+Do not insert a bridge to Screenplay's record or promise another provider accepts it.
+Arc can recover such self-contained compound bodies under the adapter gate in
+[generated recovery](../../cratis-screenplay-legacy-extraction/references/generated-recovery.md).
+Recovery does not run the body; reference execution consumes a String pin, opaque
+entropy cannot supply an identifier, and Stage rendering still refuses `generate rule`
+with STAGE-ESM-028. A target binding contract is not released renderer support.
+
 ## Inspect and edit generation through MCP
 
 A concept `generation` summary and entropy repairs are available.

package/package/corpus/skills/cratis-screenplay-command-surface/references/protected-reads.md

@@ -105,9 +105,19 @@ explicit `apply`. The repair inserts into the domain document or sole document,
 refuses ambiguous roots and requires individual review, never fix-all. It changes
 absence/conflict behavior, not merely formatting.
 
-Stage admits ESM v25 but refuses protected reads with STAGE-ESM-044 in rendering,
-Host serving and specification execution; a reference pass is not Stage or Arc
-realization. Preserve the model's protection and deliver authorized hand-written
-consistency enforcement through the render-and-gap-fill workflow. Never remove
-the preamble to get a render. `screenplay <root> --warnaserror` must exit zero;
+Stage admits ESM v25, but the Cratis C# renderer refuses protected reads with
+STAGE-ESM-044: no artifacts are emitted. Preserve protection and deliver authorized
+hand-written enforcement through render-and-gap-fill; never remove the preamble.
+
+Requires Stage 4.129.0 for semantic Host/specification-executor protected reads;
+older engines refuse STAGE-ESM-044. They require presence before requirements or
+generation and use stored read properties in requirements and produced mappings,
+including reaction-invoked commands. Any non-Error requirement on a protected
+command refuses STAGE-ESM-045 before execution, even when a rejection is expected.
+Legacy Host and structural runner still refuse the preamble with STAGE-ESM-044.
+The semantic Host faults on any outside append, even an unrelated one, before
+committing an accepted command: stricter than dependency-scoped reference conflicts,
+not proof of full conflict parity. Read Stage's [sandbox boundaries](../../cratis-stage-rendering-and-sandbox/references/sandbox-and-specrunner.md#protected-command-reads).
+A semantic-engine pass is separate from reference behavior and from generated Arc
+protection. `screenplay <root> --warnaserror` must exit zero;
 `screenplay test <root>` separately establishes reference behavior, not target support.

package/package/corpus/skills/cratis-screenplay-event-modeling/SKILL.md

@@ -174,8 +174,8 @@ compile or will not be safe. Both are deliberate.
   rejects and matching decide/commit changes conflict. Read
   [protected reads](../cratis-screenplay-command-surface/references/protected-reads.md)
   for the strict shape and paths. Legacy reads remain PLAY0271; `concurrency` is
-  not protection and cannot combine with protected reads. Stage refuses protected reads
-  (STAGE-ESM-044), not v25 itself: name target enforcement separately rather than claiming a render.
+  not protection and cannot combine with protected reads. The Cratis C# renderer refuses protected reads
+  (STAGE-ESM-044), not v25 itself: semantic Host/executor support is not generated-app protection.
   Write state-dependent rules as `reads` plus `require` with an indented message;
   mark refused shapes as unenforced and name the intended target mechanism. Model uniqueness as a `unique` constraint. Never copy state into a
   command input, add an attestation flag, or hide the rule in `handler` prose. Do not

package/package/corpus/skills/cratis-screenplay-event-modeling/references/parsed-not-runnable.md

@@ -34,7 +34,7 @@ Tool versions and consumer boundaries: toolchain `SKILL.md`.
 | Compliance concepts | Bare `pii`/`personal` and `secret`, qualifiers and scope bind as v13; enum/identity compliance and events combining personal or explicitly subject-scoped secret values with an explicit `subject` mark refuse PLAY0268 at binding only. A CLI bundle that admits v13 binds markers; Stage renders v13 protection, not protected identities/enums or subject lineage. Never remove protection |
 | Identity details / processing purposes / event subject | Report-only metadata; executable detail reads refuse PLAY0268, not source declaration errors |
 | Composite stream ids | v8 routing; complete named parts/canonical comparisons, PLAY0515 refuses protected keys/sources; not a legacy text split |
-| Command reads/concurrency | Eligible reads opt into v25 with `command reads protected`; legacy reads/concurrency retain PLAY0271; Stage refuses protected reads (STAGE-ESM-044), not the v25 pair |
+| Command reads/concurrency | Eligible reads opt into v25 with `command reads protected`; legacy reads/concurrency retain PLAY0271; the Cratis C# renderer refuses protected reads (STAGE-ESM-044), not the v25 pair; semantic Host/executor support is separate |
 | Invokes-only trigger reads | Report-only, not protected state; direct production with reads refuses |
 | Generated values/responses | v7 binding/reference execution; v15 strategies/strict fixtures/freshness. Stage renders supported UUID/String strategies, responses and fixtures; unsupported types/combinations remain -028/-038 |
 | Sources/streams and command/specification routes | v8 binding/reference execution; the CLI (toolchain `references/renderable-subset.md`) reaches Stage checks through its bundled ceiling (v16 without v17 support) |

package/package/corpus/skills/cratis-screenplay-legacy-extraction/references/generated-recovery.md

@@ -123,8 +123,20 @@ Guid, RandomNumberGenerator and GenerateValue are allowlisted; multi-statement
 bodies can qualify. Compound time-based calls must pass the captured context.
 Private helpers, fields, DI, aliases/static imports, ambient time, raw Default
 comparisons and external dependencies remain SP0073; no file fallback is invented.
-This is the Cratis C# binding to Fundamentals' GenerationContext, not a universal
-runtime type. Opaque entropy is unknown, so a rule cannot supply an identifier.
+For example, a proven forwarding factory returning
+`new($"{context.Tenant}:{context.Now:yyyyMMdd}:{GenerateValue.Ulid(context)}")`
+recovers `generate rule <Concept>New` with inline body
+`return $"{context.Tenant}:{context.Now:yyyyMMdd}:{GenerateValue.Ulid(context)}";`.
+The compound call remains a rule, not an inferred built-in ULID strategy.
+
+This uses the Cratis C# binding to Fundamentals' `Cratis.Concepts.GenerationContext`,
+not Screenplay's BCL-only record. Passing `context` to `GenerateValue.*` makes the
+body target-bound; a `csharp` tag alone does not select that binding. `Now` and the
+tenant formatted as text are the portable subset; other providers must admit the
+body against their own native type. Read the command-surface [binding guide](../../cratis-screenplay-command-surface/references/generated-values-and-responses.md#generation-context-binding)
+when deciding whether to retain target-bound code. Recovery preserves the body but
+neither executes it nor proves another target can compile it. Opaque entropy is
+unknown, so a rule cannot supply an identifier.
 The concept owns `generate`; each command property only marks generation.
 Use the shared [strategy reference](../../cratis-screenplay-command-surface/references/generated-values-and-responses.md)
 for exact encodings, ranges, entropy and admission, rather than duplicating them.

package/package/corpus/skills/cratis-screenplay-model-authoring/references/language-reference.md

@@ -271,7 +271,7 @@ See read-surface `references/named-keys.md` for the collection-key exclusion alg
 | Atomic reaction batches (ESM v22) | Root `reaction batches atomic`; direct productions per occurrence and selected refusal branches are separate batches, commands independent; Stage refuses v22 and atomic mode |
 | Described handlers (ESM v23) | Pending implementation beside unconditional produces; payload-only contract, reached body Unsupported ImplementationBody; Stage STAGE-IMPL-002 even Stub mode |
 | Ordinal text rules (ESM v24) | contains/not contains/starts with/ends with on scalar non-enum text properties; quoted literals, not conditions; Stage semantic engines execute/render |
-| Protected command reads (ESM v25) | Root `command reads protected`; eligible read paths in requirements and production mappings, absence Validation, concurrent matching facts Conflict; Stage admits v25 but refuses protected reads STAGE-ESM-044 |
+| Protected command reads (ESM v25) | Root `command reads protected`; eligible read paths in requirements and production mappings, absence Validation, concurrent matching facts Conflict; Stage admits v25; Cratis C# rendering refuses STAGE-ESM-044, semantic Host/executor execute admitted reads with non-Error protected requirements refused STAGE-ESM-045 |
 | Chronological command dates (ESM v26) | Same-primitive Date/DateTime `==`, `!=`, `>`, `>=`, `<`, `<=` in require/produces-when (property or literal RHS) and command/property rules (literal RHS only). DateTime uses UTC ticks, participating offset-less inputs reject Validation before rules; then matching stays ordinal. Requires Screenplay 4.199.0 (`screenplay --version`); older binders refuse PLAY0268. Stage refuses v26 STAGE-ESM-016. Read command-surface `references/date-comparisons.md`. |
 | Current routing and actor admission | Sources/streams and command/specification routes bind and reference-execute as v8; reaction `runs as system role` supplies the invocation actor as v10. Whole-workspace binding determines executable availability; CLI/Stage realization remains separate |
 | Blocks binding (`PLAY0268`) | enum/identity compliance and events combining personal or explicitly subject-scoped secret values with explicit subject marks; a compiler that stops before v13 refuses all `pii`/`secret` concepts ("compliance attributes require portable data-subject semantics"), while v13 binds them and Stage renders protection; attached command `handler` (PLAY0035 beside productions; pending described intent instead binds v23), bare `rule <Name>`, read paths without protected opt-in or in unsupported positions such as `produces when`, date comparisons with mixed primitives, optional condition operands, `$context`, protected read paths or `today`, date rules on concepts or reaction `where`, `$context.tenant`/claims/roles/causation in `produces`, `$env` conditions, `file` constraints, unquoted `import` of an external contract, a read model with neither explicit `key` nor unambiguous query-based identity as described above (composite keys remain unadmitted), queries with context `from` sources (typed query context is unadmitted), single-result filters (collections only), `scoped to` (opaque scope), `performer` (opaque implementation) or composite `by` blocks; optional keyed and collection queries, including caller-supplied equality filters and observable delivery, bind, `$causedBy` and templates in projections |

package/package/corpus/skills/cratis-screenplay-model-review/references/anti-patterns.md

@@ -64,7 +64,7 @@ the problem, the checks it violates, the fix, all pinned to one declaration.
 | Undeclared removal/append event | `remove with` or capture `append` names an undeclared event | V1 warns (PLAY0166, a failure under warnings as errors); binding fails PLAY0273 | C (executable) / D | declare or fix the name; run V3 |
 | Gated command invoked by a reaction without a declared actor | reaction `invokes` a command under a caller policy and has no `runs as system role "<Role>"` that satisfies the gate | the invocation carries no caller: rejected at run time | D (major) | declare `runs as system role "<Role>"` with the least-privilege role the gate admits (ESM v10, Screenplay 4.125.0; Stage 4.89.1 renders role/authenticated trusted actors, but claim-reading/opaque gates still refuse STAGE-ESM-034 and need gap-fill) or record another trusted-path decision - never just delete the gate. A matching `runs as system role` is the admitted trusted path, not a defect |
 | `reads` + `produces` reaction | reaction both reads a view and produces | fails binding | C (executable) | invoke a command, or produce without reads |
-| Unadmitted read claimed protected | rule "checked" by legacy command or trigger reads | no protected contract or target realization | D (major) | opt eligible command reads into `command reads protected` (v25); inspect shape, absence and conflict cases. Stage refuses protected reads (STAGE-ESM-044); distinguish reference protection from target evidence; checklist E3 |
+| Unadmitted read claimed protected | rule "checked" by legacy command or trigger reads | no protected contract or target realization | D (major) | opt eligible command reads into `command reads protected` (v25); inspect shape, absence and conflict cases. The Cratis C# renderer refuses protected reads (STAGE-ESM-044); distinguish reference/semantic-engine evidence from generated-app protection; checklist E3 |
 | Caller-supplied state rule | `require currentStatus == "open"` where the caller sends `currentStatus` | the caller decides its own permission | D (major) | read authoritative stored state through admitted protected reads and `require`; mark legacy/refused shapes and target realization as gaps; checklist E3 |
 | `severity warning` as soft rule | rule meant to warn but still rejects | blocks valid requests | C semantics | remove or make it a real rule |
 | Relay events | `*Synced`, `*Forwarded` events that only move data | noise, not facts | D | translate once into a business fact |

package/package/corpus/skills/cratis-screenplay-model-review/references/checklist.md

@@ -123,7 +123,7 @@ the format in `worked-example.md`.
 |---|---|---|---|
 | E1 | Value formats on `concept`s; input rules on the command; uniqueness as `constraint`; access as `authorize` | declarations | D |
 | E2 | Every refusal has a message a person understands; constraint messages copied verbatim in specs | `message`, specs | D |
-| E3 | A state-dependent rule uses `reads` + `require` over authoritative state: eligible reads opt into `command reads protected` (v25), with required absence and decide/commit conflict cases. Legacy/refused reads are marked unenforced with a named target. Stage refuses protected reads (STAGE-ESM-044); reference protection is not target realization. Not: caller-supplied copies of state, attestation booleans (`confirmsX == true`), rules in `handler` / `implementation hint` prose, or `reads` treated as protection | slice `description`, `require`, `handler` | D (faking or hiding = major) |
+| E3 | A state-dependent rule uses `reads` + `require` over authoritative state: eligible reads opt into `command reads protected` (v25), with required absence and decide/commit conflict cases. Legacy/refused reads are marked unenforced with a named target. The Cratis C# renderer refuses protected reads (STAGE-ESM-044); reference/semantic-engine evidence is not generated-app protection. Not: caller-supplied copies of state, attestation booleans (`confirmsX == true`), rules in `handler` / `implementation hint` prose, or `reads` treated as protection | slice `description`, `require`, `handler` | D (faking or hiding = major) |
 | E4 | `severity warning` is not used as "soft" validation (it still rejects) | validate lines | C semantics |
 | E5 | Preconditions are explicit; nothing relies on "obviously you can't" | descriptions, specs | Q |
 | E6 | Each invariant has an atomic enforcement point (name the storage provider where constraint admission matters); the race loser's outcome is specified | constraints, specs | D |

package/package/corpus/skills/cratis-screenplay-modeling-lifecycle/references/principles.md

@@ -11,7 +11,7 @@ instruction for the work, not background reading. Skills that restate one cite i
 6. **Keep semantic identity independent of names, paths, layout and generated symbols.** Commit the identity catalog with the model.
 7. **Keep unsupported intent visible.** Return a precise gap and its owning issue; never weaken the model so rendering passes.
 8. **Write specifications with intent, including rejection and denial.** Never report an unexecuted or unsupported scenario as passed.
-9. **Treat state reads as a correctness boundary.** Eligible command reads opt into `command reads protected` (v25); legacy/trigger reads remain unprotected. Stage refuses protected reads (STAGE-ESM-044), not the v25 pair: reference absence/conflict guarantees and verified target realization are different claims.
+9. **Treat state reads as a correctness boundary.** Eligible command reads opt into `command reads protected` (v25); legacy/trigger reads remain unprotected. The Cratis C# renderer refuses protected reads (STAGE-ESM-044), not the v25 pair: reference absence/conflict guarantees, semantic-engine execution and generated-app protection are different claims.
 10. **Separate event-source identity from event payload and choose destinations explicitly.**
 11. **Persisted event shape changes are evolution, never cleanup.** Keep historical generations.
 12. **Model external work as business intent.** Provider interfaces and transport mechanics stay out of the language.

package/package/corpus/skills/cratis-screenplay-modeling-lifecycle/references/vocabulary-map.md

@@ -21,7 +21,7 @@ speaks in them; never model board mechanics (lanes, node ids, positions).
 | Storyline (ordered beats) | a **family** of specifications sharing example data, each one transition (no storyline syntax) | several spec classes | specifications |
 | Field validation | concept `validate` (every use) / command `validate`, `require` | `ConceptValidator<T>` / `CommandValidator<T>` | command validation |
 | Role permission ("Cannot") | `policy` + `authorize` + `then denied` spec; ownership via `claim ... matches subject` | `[Authorize(Policy)]`, generated policies | authorization |
-| Precondition on stream state | `command reads protected` + eligible `reads`/`require` (v25 reference protection); legacy/refused reads remain stated intent. Stage refuses protected reads (STAGE-ESM-044); target Arc `[ProtectedDecision]` + `DecisionRead<T>` or Chronicle DCB needs separate verification | decision over a guarded read | command validation |
+| Precondition on stream state | `command reads protected` + eligible `reads`/`require` (v25 reference protection); legacy/refused reads remain stated intent. The Cratis C# renderer refuses protected reads (STAGE-ESM-044); semantic-engine execution is separate from generated-app protection. Target Arc `[ProtectedDecision]` + `DecisionRead<T>` or Chronicle DCB needs separate verification | decision over a guarded read | command validation |
 | Generated id (`derived:uuid4()`) | `generated` (authorable, not executable) | id supplied before `Handle()` | commands |
 | External system / outbound call | `Translate` slice (inbound); `system`/`operation` (authorable, not executable) or Automation (outbound) | `ICommandOperation` / reactor | operations, reactors |
 | HTML mockup | `screen` Level 1 + board (`visualize-model`) | default Scene composition | ui composition |

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

@@ -35,8 +35,9 @@ Tool versions are covered in `cratis-screenplay-toolchain` `SKILL.md`; read it b
 ## Language modes that block target delivery
 
 Read [language admission](../cratis-screenplay-toolchain/references/language-admission.md)
-for v22–v25: Stage refuses atomic batches, described bodies (even Stub mode) and
-protected reads. Preserve contracts; reference success is not target realization.
+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.
+Preserve contracts; reference success is not target realization.
 
 ## Interview phase
 **Skip if** the request names the model root, the application name, the destination and the

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

@@ -111,7 +111,9 @@ invoked commands independent. Stage refuses v22 (STAGE-ESM-016) and atomic mode
 in admitted v23–v25 (STAGE-ESM-043); the declaration is not external-effect deduplication.
 For described handlers, hand off only payload computation under the v23 result
 contract; Stage STAGE-IMPL-002 means no stubs, even Stub mode. Protected v25 reads
-refuse STAGE-ESM-044 despite version admission and need target admission/enrollment tests; ordinary injection never supplies protection.
+refuse Cratis C# rendering with STAGE-ESM-044 despite version admission and need
+generated-app admission/enrollment tests; ordinary injection never supplies protection.
+Semantic Host/executor support is a separate result, not generated-app enforcement.
 
 ## Re-delivery
 The work list is the full in-scope contract delta since the fallback record's last verified source

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

@@ -31,10 +31,15 @@ ESM). Only the probe answers renderability. `PLAY0270` entries are information,
 | Class | Meaning | Typical examples (each verified in `admission.md`) | Action |
 | --- | --- | --- | --- |
 | **Model fix (in mode)** | the model is in, or the user chose, renderable mode and breaks its own subset in a way that has a renderable equivalent with the same meaning | a `produces` whose `for` is not the command identifier; two projections for one read model (`-007`); a policy Stage cannot express portably (`-015`; role-only and opaque pure policies render) | edit request to the modeler session with address, change and rationale |
-| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to`/`performer` and composite `by` remain PLAY0268; Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected reads (STAGE-ESM-044 despite v25 admission); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v25) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
+| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to`/`performer` and composite `by` remain PLAY0268; Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected-read rendering (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v25) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
 | **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 |
 
+Requires Stage 4.129.0 for semantic Host/executor protected reads; older engines
+refuse STAGE-ESM-044. Non-Error protected requirements refuse STAGE-ESM-045, including
+reaction invocations. A semantic-engine pass does not resolve the rendering gap;
+read [sandbox boundaries](../../cratis-stage-rendering-and-sandbox/references/sandbox-and-specrunner.md#protected-command-reads).
+
 ## Triage rules
 - A capability gap never becomes a model fix by deleting meaning. Turning a list screen into a
   keyed lookup, dropping `pii`, removing authorization or a rule, or splitting a conditional

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

@@ -4,7 +4,7 @@ This is a legacy control without `command reads protected`; the unprotected-read
 markers below describe that control, not all command reads. Eligible views can opt
 into v25; the date-rule blocker still remains. Read
 [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
-for admission and Stage's protected-read refusal (STAGE-ESM-044).
+for admission and the Cratis C# renderer's protected-read refusal (STAGE-ESM-044).
 
 Complete, compiled design-mode model (marina guest berths) showing a coverage matrix turned into specifications: happy path, one rejection per rule, authorization denial, duplicate and retry, competing claim, state violation, alternative branches, compensation and a view lifecycle family. The matrix for it is in `coverage-matrix.md`; the catalogue (`scenario-catalogue.md`) names its specifications.
 

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/invoicing-dues-design.md

@@ -4,7 +4,7 @@
 Read [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
 for the opt-in alternative. Do not insert the preamble blindly: every read must meet
 finite event-source-keyed admission with removals. A v25 reference pass still does not
-render protected reads: Stage admits v25 but refuses them with STAGE-ESM-044. The comments and unenforced markers below describe
+render protected reads: Stage admits v25 but the Cratis C# renderer refuses them with STAGE-ESM-044. The comments and unenforced markers below describe
 this legacy control, not a general limit on command reads.
 
 **Design mode.** This document states the stored-state rules of the

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

@@ -40,7 +40,7 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | Pending described command handlers (v23) | specify intent | binds; denial/validation execute, body-reaching specs Unsupported ImplementationBody; all-Unsupported is not green | STAGE-IMPL-002 even Stub mode |
 | Attached command handlers, `file` constraints, query `performer`s | spec them in design | blocked: PLAY0268 at binding, no spec runs (V3 blocked) | no |
 | Atomic reaction mode (v22) | declare for new models | failed batch adds no facts or view changes; earlier batches/commands remain; `then error` alone is insufficient | v22 STAGE-ESM-016; mode in admitted v23–v25 STAGE-ESM-043 |
-| Protected command reads (v25) | declare opt-in for eligible reads | absence Validation; matching intervening facts Conflict; race vectors are not a new spec construct | protected reads STAGE-ESM-044; v25 pair admitted |
+| Protected command reads (v25) | declare opt-in for eligible reads | absence Validation; matching intervening facts Conflict; race vectors are not a new spec construct | Cratis C# rendering STAGE-ESM-044; semantic Host/executor execute admitted reads, non-Error protected requirements STAGE-ESM-045; v25 pair admitted |
 
 Requires Screenplay 4.105.0 or later (`screenplay --version`) for list-query specifications, and 4.143.0 or later for collection equality filters (ESM v14).
 

package/package/corpus/skills/cratis-screenplay-slice-design/references/rule-layers.md

@@ -20,7 +20,7 @@ protected decisions. Gap-fill must use an admitted projection/key shape and acti
 unit-of-work enrollment; do not edit managed dependencies. Keep the `.play` rule
 target enforcement separate from reference semantics until target tests verify it.
 Read [protected command reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
-for admission and Stage's protected-read refusal (STAGE-ESM-044); never remove protection to obtain rendering. Forbidden: caller-supplied copies of state in `require`, boolean attestation
+for admission and the Cratis C# renderer's protected-read refusal (STAGE-ESM-044); never remove protection to obtain rendering. Forbidden: caller-supplied copies of state in `require`, boolean attestation
 inputs (`confirmsX == true`), rules in `handler` / implementation-hint prose.
 
 ## Authorization is executable

package/package/corpus/skills/cratis-screenplay-slice-design/references/worked-example.md

@@ -5,7 +5,7 @@ One complete legacy design-mode control for `cratis-screenplay-slice-design`, wi
 specification runs here. List queries and clock fixtures bind on an admitting compiler;
 they are not the remaining blocker. Personas and screens are informational.
 Eligible command reads can opt into v25; inspect every projection/key/removal before
-migration and retain Stage's separate refusal (STAGE-ESM-044; the v25 pair itself is admitted). Read
+migration and retain the Cratis C# renderer's separate refusal (STAGE-ESM-044; the v25 pair itself is admitted). Read
 [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
 The unenforced descriptions below refer to this legacy control, not all command reads.
 The specifications still seed every read-model source (`LockerInstalled`, `LockerRequested`,

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

@@ -114,7 +114,7 @@ Unattended work takes the conservative option and marks it `ASSUMED` in model
   conflict. Legacy reads remain PLAY0271/PLAY0268; `concurrency` remains unbound and
   combining it with protected reads is PLAY0783. Read
   [protected reads](../cratis-screenplay-command-surface/references/protected-reads.md)
-  for admission and Stage's STAGE-ESM-044 protected-read refusal (the v25 pair itself is admitted). `description` text never reaches rendered code: a rule that lives only in prose is
+  for admission and the Cratis C# renderer's STAGE-ESM-044 protected-read refusal (the v25 pair itself is admitted). `description` text never reaches rendered code: a rule that lives only in prose is
   unenforced there.
 - `pii` and `secret` bind as ESM v13;
   enum/identity compliance and protected events with explicit subject marks still

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

@@ -58,7 +58,7 @@ observed legacy check from verified atomic protection.
 | a value across all sources | `unique <prop> on <Event>` | value owned by one source; same source may re-claim |
 | a fact at most once per source; mutually exclusive facts | `unique event` (+ `released by`) | covers simple lifecycle transitions |
 | state-dependent rule (balance, capacity, "only if approved") | eligible `reads` + `require` under `command reads protected` (v25) | required absence rejects; matching intervening facts conflict. Payload-key fan-in, joins, reducers and other refused shapes remain target gaps |
-| a view (read model) | unguarded materialized reads are not protection | legacy command and trigger reads remain unprotected; Stage refuses protected reads (STAGE-ESM-044), so reference protection is not target realization |
+| a view (read model) | unguarded materialized reads are not protection | legacy command and trigger reads remain unprotected; the Cratis C# renderer refuses protected reads (STAGE-ESM-044); semantic Host/executor evidence is not generated-app protection |
 
 ## 3. Record each state-dependent rule that the model cannot enforce
 Never accept the caller's copy of the state: `currentStatus Status` on the command with
@@ -69,7 +69,8 @@ the rule unenforced in rendered scope.
 
 First inspect [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md):
 opt eligible command reads into v25, retain absence/conflict specifications and verify
-target consistency separately. Stage admits v25 but refuses protected reads (STAGE-ESM-044). A payload-keyed
+target consistency separately. Stage admits v25 but the Cratis C# renderer refuses protected reads (STAGE-ESM-044).
+Semantic Host/executor support has separate severity and outside-append limits. A payload-keyed
 fan-in such as the course-capacity example remains refused; the preamble is not a
 blanket admission of arbitrary projections.
 

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

@@ -4,7 +4,7 @@ Legacy control: no `command reads protected` preamble is declared. The course-ca
 payload-key fan-in remains refused even with opt-in; eligible active-enrolment reads
 can protect under v25, but reads plus concurrency cannot combine (PLAY0783). Read
 [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
-for admission and Stage's protected-read refusal (STAGE-ESM-044). The legacy diagnostics below describe this
+for admission and the Cratis C# renderer's protected-read refusal (STAGE-ESM-044). The legacy diagnostics below describe this
 control, not a blanket refusal of command reads.
 
 A complete design-mode model for course enrolment. It shows one business identity per stream,

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

@@ -326,13 +326,16 @@ refusal reasons. Read [language admission](language-admission.md) before changin
 | PLAY0786 (I) | Eligible legacy model; preview typed preamble repair, individually review absence/conflict semantics |
 | PLAY0787 (W) | Exact deprecated Studio text-rule pattern; repair to literal rule or equality, preserving message/severity |
 | STAGE-ESM-043 | Atomic mode not realized, even in admitted v23–v25; retain declaration and gap-fill |
-| STAGE-ESM-044 | Protected reads not realized despite v25 version admission; keep protection and gap-fill |
+| STAGE-ESM-044 | Cratis C# renderer refuses protected reads despite v25 admission; 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 |
 
 Invalid match syntax remains PLAY0367. Property/concept text rules bind v24;
 `contains`/`starts with` in conditions only still fail PLAY0268. Stage rejects
 v22/v26 and mixed pairs with STAGE-ESM-016; v23–v25 admission does not implement
-bodies, batches or protected reads (STAGE-ESM-044).
+bodies, batches or rendered protected reads (STAGE-ESM-044). Requires Stage 4.129.0
+for semantic Host/executor protected reads; older engines refuse -044. Read
+[language admission](language-admission.md) for the stricter Host outside-append guard.
 
 ## Binding (V2 and V3) - see `executable-subset.md` for the full table
 | Code | Meaning | Fix |

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

@@ -12,7 +12,7 @@ exact language/semantic pairs; binding, reference execution and rendering are se
 | v22 | Application-root `reaction batches atomic` | Direct productions per trigger occurrence and each selected refusal branch are separate atomic batches; commands remain independent | v22 refused STAGE-ESM-016; mode in admitted v23–v25 refused STAGE-ESM-043 |
 | v23 | Pending `handler implementation` beside unconditional `produces` | Payload-only body; PLAY0695 information; reaching body gives Unsupported ImplementationBody | v23 admitted, body refused STAGE-IMPL-002 in renderer/Host/executor, even Stub mode |
 | v24 | `contains`, `not contains`, `starts with`, `ends with` property/concept rules | Ordinal UTF-16, absent optional passes; not text-condition operators | v24 admitted; semantic Host/executor and generated ordinal comparisons preserve rules |
-| v25 | Application-root `command reads protected` | Admitted reads in requirements/mappings, absence Validation, matching decide/commit changes Conflict | v25 admitted; protected reads refused STAGE-ESM-044 in renderer/Host/executor |
+| v25 | Application-root `command reads protected` | Admitted reads in requirements/mappings, absence Validation, matching decide/commit changes Conflict | v25 admitted; Cratis C# renderer refuses STAGE-ESM-044; 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 refused STAGE-ESM-016 |
 
 Requires Screenplay 4.181.0 or later (`screenplay --version`) for atomic batches; older compilers cannot admit the preamble.
@@ -27,7 +27,9 @@ Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`) for date compariso
 
 Requires Stage 4.124.0 for v24 text-rule admission (`cratis --version` identifies the CLI bundle); older renderers refuse v24 with STAGE-ESM-016. V23 admission alone does not implement described bodies.
 
-Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. Protected reads still refuse STAGE-ESM-044, including on legacy paths; no artifacts are emitted.
+Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. The Cratis C# renderer still refuses protected reads with STAGE-ESM-044; no artifacts are emitted.
+
+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).
 
 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
@@ -56,6 +58,6 @@ for the complete interval example and input/target boundaries.
 
 Stage's semantic engines admit exact v1–v21 and v23–v25 pairs. V22/v26 and mixed
 pairs refuse STAGE-ESM-016. Admission of v23–v25 is not admission of described bodies,
-atomic mode or protected reads. A CLI may bundle an older compiler/Stage pair: run no-write render
+atomic mode or rendered protected reads. A CLI may bundle an older compiler/Stage pair: run no-write render
 admission rather than transferring a standalone verdict. Pattern diagnostics arise
 in Screenplay before rendering; diagnostic arguments add no ESM version or new tool.

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

@@ -60,12 +60,14 @@ This table is a reading of the renderer's admission, not a render result: run th
 | Evolved events | initial revisions only (migrations are not rendered) | `STAGE-ESM-026` |
 | Descriptions, documentation | XML `<summary>`/`<remarks>` doc comments only | characters invalid in XML: `CLI-RENDER-005`; never behavior |
 
-Stage refuses protected command reads with STAGE-ESM-044, described handlers
+The Cratis C# renderer refuses protected command reads with STAGE-ESM-044, described handlers
 with STAGE-IMPL-002 (even Stub mode), and atomic mode in admitted pairs with
 STAGE-ESM-043. Literal
 text rules execute/render ordinal UTF-16 comparisons. Read [language admission](language-admission.md).
 A CLI's older bundled compiler may fail first: legacy reads/concurrency PLAY0271,
-attached handlers PLAY0268. Protected reads bind standalone v25, not a Stage render.
+attached handlers PLAY0268. Protected reads bind v25, not a Stage render. Requires Stage 4.129.0 for semantic
+Host/executor protected reads; older engines refuse -044. Non-Error protected requirements
+refuse STAGE-ESM-045, including reaction invocations; this is not a rendering result.
 Response-name authoring scopes are not rendered and Scene runtime does not supply them.
 
 Compliance mapping in the generated C#: personal data to `[PII]`, operational secrets to

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

@@ -42,7 +42,7 @@ Compiler syntax: `cheat-sheet.md`. Negative capability claims depend on the tool
 35. `description`/`documentation` are authoring metadata: board, MCP and Prologue show them; `cratis render` emits them only as XML doc comments (invalid XML characters are CLI-RENDER-005), never as behavior. A rule only in prose is unenforced in rendered code; make it a rule layer, a spec or a recorded target requirement.
 36. One unadmitted construct (operations, `numbers exact`, composite view keys) blocks whole-model binding. Routing is admitted (v8), unlike composite view keys. Overrides replace the whole route, filters never match unrouted facts. Do not remove routing or authorization to render a model.
 37. Personas remain outside ESM bytes, but specifications accept `given caller as <Persona>`: one authenticated deterministic policy witness, not every matching caller. Inspect the chosen `or` branch; use explicit callers when synthesis is refused.
-38. A stored-state rule uses `reads <View>` and `require` with an indented message. Opt into `command reads protected` for eligible v25 views; absence rejects and matching decide/commit changes conflict. Legacy reads remain unprotected. Stage refuses protected reads (STAGE-ESM-044), not the v25 pair: hand-written Arc `[ProtectedDecision]` + `DecisionRead<T>` or Chronicle consistency enforcement needs separate target verification; use a constraint for uniqueness. Forbidden: caller-supplied copies of state in `require`, boolean attestation inputs (`confirmsX == true`), rules hidden in `handler`/implementation-hint prose. An unguarded materialized read is unsafe for a protected decision.
+38. A stored-state rule uses `reads <View>` and `require` with an indented message. Opt into `command reads protected` for eligible v25 views; absence rejects and matching decide/commit changes conflict. Legacy reads remain unprotected. The Cratis C# renderer refuses protected reads (STAGE-ESM-044), not the v25 pair; semantic Host/executor support is separate: hand-written Arc `[ProtectedDecision]` + `DecisionRead<T>` or Chronicle consistency enforcement needs separate target verification; use a constraint for uniqueness. Forbidden: caller-supplied copies of state in `require`, boolean attestation inputs (`confirmsX == true`), rules hidden in `handler`/implementation-hint prose. An unguarded materialized read is unsafe for a protected decision.
     Requires Arc 22.39.0 or later for `[ProtectedDecision]`.
 
 Identity and compliance traps (`identity.md`, `concepts.md`, `events.md`, `purposes.md`, `diagnostics.md` in the Screenplay documentation):

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

@@ -21,7 +21,8 @@ Requires cratis CLI ≥ 3.57 (`cratis --version`) to render ESM v14 and v15 mode
 
 Read [language admission](../cratis-screenplay-toolchain/references/language-admission.md)
 for v22–v25: text rules render, atomic batches/protected reads/described bodies do
-not. Stub mode emits no described-body stubs. Keep protection and report refusal.
+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.
 
 ## When to use
 
@@ -128,7 +129,7 @@ One blocker publishes nothing. Codes, limits and fixes: [references/admission.md
   (`-032`/`-033`), claim-reading/opaque `runs as` gates (`-034`), legacy filters (`-035`), production
   overrides (`-036`), code validation (`-005`), DateTime filters (`-010`),
   unsupported conditional productions, composite projection keys and unsupported `all` shapes.
-  Protected reads refuse `STAGE-ESM-044`, described handlers `STAGE-IMPL-002`
+  The Cratis C# renderer refuses protected reads with `STAGE-ESM-044`, described handlers `STAGE-IMPL-002`
   (even Stub mode), and atomic mode in admitted pairs `STAGE-ESM-043`.
 - **Binding refusals (`PLAY0268`/`PLAY0271`):** legacy reads, `concurrency`, attached
   handlers, context/single-result filters, opaque scope/performer, composite `by`,
@@ -159,7 +160,8 @@ files, a policy registration and generated policies, `Common/<Concept>.cs`, one
 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: [references/rendered-application.md](references/rendered-application.md). Scene
+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:
 [references/render-example.md](references/render-example.md).
@@ -190,7 +192,13 @@ disposable runtime**, not a generated application. The default engine appends mo
 simple literal `validate` rules on top-level properties, but enforces no other rule, no
 constraint and no command or query authorization; `Stage__Runtime__Engine=semantic` opts
 in to an engine that does, and refuses what it cannot execute (HTTP 501). The default engine
-also refuses routed models (`STAGE-ESM-030`). Callers are built from unsigned headers, so
+also refuses routed models (`STAGE-ESM-030`) and protected reads (`STAGE-ESM-044`).
+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

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

@@ -29,10 +29,11 @@ Requires Stage 4.119.0 for pattern/random rendering, Host generation and indepen
 opaque/unsupported rules refuse -005 before pin evaluation. Independent execution
 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. Protected reads still refuse STAGE-ESM-044.
+Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. The Cratis C# renderer still refuses protected reads with STAGE-ESM-044.
+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.
 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 protected decision. Chronological Date/DateTime command comparisons
+batch or rendered protected decision. Chronological Date/DateTime command comparisons
 select v26 in Screenplay but still refuse STAGE-ESM-016 here; standalone reference
 success is not rendering or Host/executor admission. Keep the date rule and use
 authorized gap-fill rather than downgrading to ordinal text or millisecond precision.
@@ -162,7 +163,8 @@ Requires Stage 4.90.0 for snapshot/live lists, 4.96.0 for non-text secrets and 4
 | `STAGE-ESM-041` | Older renderers refuse non-text secrets; supported renderers keep their original types | Keep classification; upgrade the renderer, never declassify |
 | `STAGE-ESM-042` | Unknown validation rule kinds; checksum on the legacy syntax path (semantic checksum renders) | Keep the rule; use an admitting semantic renderer or gap-fill |
 | `STAGE-ESM-043` | `reaction batches atomic` in an admitted version pair | Keep the batch boundary; gap-fill without splitting it |
-| `STAGE-ESM-044` | Protected-read preamble, command reads or read-backed conditions/mappings in renderer, Host or specification executor | Keep protection; gap-fill with independently verified target enforcement |
+| `STAGE-ESM-044` | Protected-read preamble, command reads or read-backed conditions/mappings in the Cratis C# renderer; legacy Host/structural runner also refuse the preamble | Keep protection; semantic Host/executor support is separate from generated-app enforcement |
+| `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-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 |

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

@@ -3,6 +3,7 @@
 ## Contents
 
 - Scaffold
+- Reducer layout for new applications
 - What is managed
 - `Customizations/` (unmanaged)
 - Re-render checklist
@@ -35,13 +36,52 @@ Consequences: `[ProtectedDecision]` (`Cratis.Arc.Chronicle.ReadModels`) and
 in the scaffold's package set, as is `[ExecuteCommandsAsSystem]`. This is API
 availability, not Stage emission or runtime protection: gap-fill must opt into
 the protected command profile and enroll an admitted projection/key read in the
-active unit of work. Stage does not turn `.play` `reads`/`require` into protected decisions.
+active unit of work. The Cratis C# renderer does not turn `.play` `reads`/`require` into protected decisions;
+semantic Host/executor support is separate from generated-application protection.
 Hand-written scope that needs a newer dependency can raise its version through
 `Customizations/Dependencies.props` (explicit `Version`, imported last; central management
 is off), but any override must be proven with a restore and build. The compose file binds local ports `27017` and
 `35000`, keeps data in the named volumes `chronicle-data` and `chronicle-config`, and
 `docker compose down --volumes` is the only thing that deletes them.
 
+## Reducer layout for new applications
+
+Requires Stage 4.128.0 for the Cratis C# self-reducing profile; older renderers emit
+separate `IReducerFor<T>` classes. Existing `CreateProfile` callers remain classic;
+a missing destination/configuration file does not identify a new application.
+For a **confirmed new application**, artifact-planning hosts opt in explicitly:
+
+```csharp excerpt
+var profile = CratisRendering.CreateNewApplicationProfile(
+    "Shop", new("Shop.Backend", "Acme.Shop"));
+```
+
+This API is in `Cratis.Stage.Rendering.Cratis`. Pass the profile to scaffold and
+artifact planning through `CratisPlanOptions.Profile`. The scaffold persists
+`.cratis/stage/rendering.json` with exactly
+`{"version":1,"application":"Shop","reducerConvention":"self"}`. On later renders,
+the host reads that file and restores the input; Stage does not search the destination:
+
+```csharp excerpt
+var input = ReducerConventionInput.Read("Shop", configurationJson);
+var profile = CratisRendering.WithReducerConvention(
+    CratisRendering.CreateProfile("Shop", new("Shop.Backend", "Acme.Shop")), input);
+```
+
+`configurationJson` is the host-supplied file content. Invalid version, application,
+fields or convention are refused, not defaulted. Self mode emits public static
+`Reduce` overloads and non-public typed-context helpers on the read-model record,
+with unchanged queries and no companion `IReducerFor<T>`. StateView and Automation
+slices use the layout; observer filters become model attributes. Existing purity,
+identity, tenant, deletion and occurrence semantics remain. Model/property/query
+name `Reduce`, replay-hook query names, or generated `Transition_<suffix>` collisions
+refuse `STAGE-ESM-019`; Stage never silently changes layout.
+
+No per-model override or existing-application migration is supported. Do not flip
+an existing classic application to `self`: observer identity and old reducer removal
+need migration-aware publication. This opt-in does not automatically change CLI,
+Studio or semantic-engine execution.
+
 ## What is managed
 
 Every path in `.cratis-render.json` is managed: the scaffold files (project, solution,

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

@@ -3,6 +3,7 @@
 ## Contents
 
 - The sandbox: a partial, disposable runtime
+- Protected command reads
 - Refusals shared by both engines
 - The specification runner
 - Choosing between them
@@ -101,6 +102,32 @@ A refusal or an acceptance from the default engine therefore proves nothing beyo
 lists above. Use the semantic engine, or Debug tests of a render, for
 evidence about the rest.
 
+## Protected command reads
+
+Requires Stage 4.129.0 for semantic Host and specification-executor protected reads;
+older engines refuse them with `STAGE-ESM-044`. The default EventModel Host and
+structural runner still refuse the preamble with `STAGE-ESM-044`; the structural
+runner exits `1` without a report. The Cratis C# renderer also retains `-044`:
+executing a model here does not make it renderable.
+
+After authorization and property/concept rules, each declared read must exist at
+its key. Missing state rejects with `<View> '<key>' does not exist.` before any
+requirement or generation, even a command-only requirement. `/validate` reports
+absence too. Present read properties feed `require` and produced-event mappings.
+The executor projects prior facts through Chronicle's in-memory read-model scenario,
+preserving event-source-keyed removal and recreation. Join removals, parent keys,
+children and nested scopes remain refused.
+
+A protected command with any non-Error requirement refuses `STAGE-ESM-045` before
+execution. This includes reaction-invoked commands, even a specification expecting
+rejection: the outcome is `Unsupported`, before seeding facts, not a passing refusal.
+Do not change modeled severity to get an executable result.
+
+The semantic Host faults the session on **any outside append** to its event log,
+even an unrelated one, before committing an accepted command. This interim guard
+is stricter than the reference's dependency-scoped decide/commit conflicts; do not
+claim full reference conflict parity or generated-application protection.
+
 ## Refusals shared by both engines
 
 Both engines refuse public events (`STAGE-ESM-032`), foreign or source-event captures
@@ -141,7 +168,7 @@ invalid semantic option.
 - **Semantic**: creates a fresh in-memory Chronicle log per specification and dispatches
   admitted commands through Arc's in-memory pipeline; supports explicit-source and routed
   given events, unconditional production, event assertions, caller and authorization,
-  command rules, unique constraints, flat and event-source-keyed scoped projections, and
+  command rules, protected command reads (including reaction invocations), unique constraints, flat and event-source-keyed scoped projections, and
   optional snapshot queries, including protected ones: portable authorization is evaluated
   with the fixture caller, query arguments and key, and an expected denial matches only
   `then denied`. Report schema `stage-spec-run/1` with outcomes
@@ -150,6 +177,10 @@ invalid semantic option.
   allocation, external effects, composite values, queries other than optional snapshots, and
   a reached opaque authorization policy (reported as `Unsupported`). Unsupported is never a pass. Do not feed the file to a legacy reader.
 
+The runner and generated-fixture checks use Screenplay's public
+`SemanticValidationRules.Check`. This shared rule check does not execute opaque
+generation or validation bodies.
+
 How the runner relates to the verdicts: a structural pass is not a behavioral result. The
 semantic engine is Stage's own executor running through Arc's in-memory pipeline. It is
 not the Screenplay reference route, so a semantic pass is never V4 (V4 is reference

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

@@ -62,6 +62,16 @@ The scaffold's Scene runtime provides:
   imports and network assets; an explicit importer map is not arbitrary module
   loading. Diagnostics block mismatched or unavailable bundles.
 
+Requires Stage 4.130.0 for Stage shell selection from `ui profile` root template,
+options and appearance; older hosts do not apply that complete shell contract.
+The Host and render plan use Scene's shell resolution: root, legacy layout,
+default blueprint layout, then bare shell. Unknown/unavailable/version-mismatched
+roots and roots lacking a `content` outlet produce planning findings or an explicit
+Host startup message, never silent fallback. Shell options such as `navigationMode`,
+`menuTheme` and `showFooter` are applied or reported unsupported. Light/dark/system
+color scheme and accent reach the shell; runtime Scene carries root, appearance
+and defaults but no sample data. Browser evidence is still needed for UI parity.
+
 Keep authoring acceptance, executable admission and runtime behavior separate.
 Require Stage's plan/diagnostics for emission and a browser run for UI parity;
 source verification alone proves neither. For authoring details read

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratis/pi",
-  "version": "7.64.0",
+  "version": "7.65.0",
   "description": "Configuration-aware Cratis AI integration for Pi",
   "type": "module",
   "files": [