@cratis/pi 7.63.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",
@@ -171,9 +171,9 @@
         }
       ],
       "synced": {
-        "version": "4.198.0",
+        "version": "4.199.0",
         "date": "2026-10-16",
-        "by": "Cratis/AI#576"
+        "by": "Cratis/AI#735"
       },
       "covers": {
         "skills": [
@@ -201,7 +201,7 @@
         ],
         "rules": []
       },
-      "notes": "Standalone 4.198.0 and byte-identical compiler contract pinned. Cratis/AI#576: mechanical compiler catch-up. Language batch #717/#722/#723/#724/#720/#728/#734 teaches atomic reaction batches (v22), described payload handlers (v23), portable linear matching, ordinal text rules (v24), protected command reads (v25), diagnostic arguments and event-source invokes mappings. Facts read at Screenplay v4.198.0 and introducing tags; Stage v4.127.0 admits exact v1-v21 and v23-v25 pairs but refuses v22/v26 and mixed pairs (STAGE-ESM-016), protected reads (044), atomic mode (043) and described handlers (STAGE-IMPL-002), even Stub mode. Stage text rules execute/render; no new renderer/runtime probe or Stage pin uplift. Cratis/AI#706: application navigation regions (module inherit, extend or override), toolbar slice buttons, blueprint template references and sample data packs in cratis-screenplay-ui-composition (references/application-shell.md), with the canonical shell vector and the rejection codes PLAY0710-PLAY0722 and PLAY0740-PLAY0765. Examples moved to the executable-state rules since 4.164: translator reactions in an Automation slice beside the Translate slice (PLAY0694) and the first record of a capture key appended with `when added`. Earlier: Standalone 4.164.0 and byte-identical compiler contract pinned. Cratis/AI#663: one origin per capture (PLAY0687). #668: executable no-event/redelivery v17. #684: concept query-argument validation in every version and query-error assertions v18. #681: executable refusal branches and refusal values v19. #666: proposal summary/severity counts and exact structural source proposals. Generated-concept rules select v20 with PLAY0688/0689 proofs and derived-matches repair; generated secrets and preview strategies remain refused. Release-baseline from-esm admission reads storedName. Standalone binding is not renderer admission: Stage 4.103.0 admits v1-v17 and v19; CLI 3.62.0 bundles Screenplay 4.159.0 / Stage 4.99.0 and renders through v16. Prior evidence remains unless superseded; no new renderer, Docker or browser probe."
+      "notes": "Standalone 4.199.0 and byte-identical compiler contract pinned. Cratis/AI#735: chronological Date/DateTime ordering in command conditions and command/property literal validation (ESM v26), UTC tick precision and pre-rule offset validation; then matching remains ordinal. Source-checked Screenplay v4.199.0 commands, diagnostics, interoperability and specifications documentation plus decision 0087. Stage v4.127.1 still refuses v26 with STAGE-ESM-016 (stage-rendering.md and SemanticVersionFeatures.Supports); no render/runtime probe. Cratis/AI#576: prior mechanical compiler catch-up. Language batch #717/#722/#723/#724/#720/#728/#734 teaches atomic reaction batches (v22), described payload handlers (v23), portable linear matching, ordinal text rules (v24), protected command reads (v25), diagnostic arguments and event-source invokes mappings. Facts read at Screenplay v4.198.0 and introducing tags; Stage v4.127.0 admits exact v1-v21 and v23-v25 pairs but refuses v22/v26 and mixed pairs (STAGE-ESM-016), protected reads (044), atomic mode (043) and described handlers (STAGE-IMPL-002), even Stub mode. Stage text rules execute/render; no new renderer/runtime probe or Stage pin uplift. Cratis/AI#706: application navigation regions (module inherit, extend or override), toolbar slice buttons, blueprint template references and sample data packs in cratis-screenplay-ui-composition (references/application-shell.md), with the canonical shell vector and the rejection codes PLAY0710-PLAY0722 and PLAY0740-PLAY0765. Examples moved to the executable-state rules since 4.164: translator reactions in an Automation slice beside the Translate slice (PLAY0694) and the first record of a capture key appended with `when added`. Earlier: Standalone 4.164.0 and byte-identical compiler contract pinned. Cratis/AI#663: one origin per capture (PLAY0687). #668: executable no-event/redelivery v17. #684: concept query-argument validation in every version and query-error assertions v18. #681: executable refusal branches and refusal values v19. #666: proposal summary/severity counts and exact structural source proposals. Generated-concept rules select v20 with PLAY0688/0689 proofs and derived-matches repair; generated secrets and preview strategies remain refused. Release-baseline from-esm admission reads storedName. Standalone binding is not renderer admission: Stage 4.103.0 admits v1-v17 and v19; CLI 3.62.0 bundles Screenplay 4.159.0 / Stage 4.99.0 and renders through v16. Prior evidence remains unless superseded; no new renderer, Docker or browser probe."
     },
     {
       "id": "scene",

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
@@ -177,11 +178,18 @@ optional `severity`, sharing the condition grammar with `produces … when`:
 `and` binds tighter than `or`, parentheses group. A conditional rule is an
 implication: `require isExtension == false or newEndDate > endDate`.
 
+Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`) for Date/DateTime
+comparisons; older binders report PLAY0268. Read [date comparisons](references/date-comparisons.md)
+when ordering a retention window with `require to >= from`, comparing instants
+across offsets, or rejecting offset-less inputs before rules. It covers admitted
+positions, PLAY0268/0273, ordinal `then` matching and Stage's v26 refusal.
+
 **Rules whose logic is code.** A bare `rule <Name>` has no portable meaning (`PLAY0268`) and a bodied rule binds only as
 opaque code. Read [references/validate-rules.md](references/validate-rules.md) when a rule's logic must live in a `file`
 or fenced code body.
 
-**Put format rules on the `concept`, not the command.** A concept carries its own
+**Put format rules on the `concept`, not the command** (except date comparisons,
+which bind only on command properties, not as concept rules). A concept carries its own
 `validate` block and every use inherits it — that is Screenplay's type system, and
 a rule that travels is worth more than one that is repeated.
 
@@ -281,7 +289,9 @@ Four contexts, and **what each omits is load-bearing** — when writing a code b
       bundle compatibility and execution are separate checks.
 - [ ] No unintended `PLAY0478` or `PLAY0479` information remains.
 - [ ] At most one command property carries `identifier`, and no event property does.
-- [ ] Format rules live on the `concept`; state-dependent rules are specifications.
+- [ ] Format rules live on the `concept` except command-only date comparisons;
+      state-dependent rules are specifications. DateTime comparisons preserve UTC
+      ticks; specs include missing-offset Validation rejection.
 - [ ] Every `authorize` combining policies writes `and`/`or` explicitly.
 - [ ] Protected reads opt in, meet admission and distinguish reference protection
       from target realization; legacy reads and `concurrency` imply no protection.

package/package/corpus/skills/cratis-screenplay-command-surface/references/date-comparisons.md

@@ -0,0 +1,100 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Chronological command date comparisons
+
+Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`); older binders refuse date comparisons with PLAY0268. Upgrade the compiler without weakening the rule.
+
+Use `==`, `!=`, `>`, `>=`, `<` or `<=` with matching primitives: Date/Date or
+DateTime/DateTime. A concept may type a command property; date rules on the concept
+itself remain refused. These are the admitted positions:
+
+| Position | Left | Right |
+| --- | --- | --- |
+| `require`, `produces when` | Required scalar command property | Required scalar command property of the same primitive, or literal |
+| Command/property validation rule | Subject property | Literal only |
+
+`Date` orders calendar dates without a time zone. `DateTime` compares UTC instants
+at tick precision (seven fractional digits), including `==`/`!=`: different offsets
+can name equal instants. Literal operands bind to canonical text (`yyyy-MM-dd`, or
+UTC `yyyy-MM-ddTHH:mm:ss.fffffffZ`). An unparsable date literal or an offset-less
+DateTime literal in an admitted position reports PLAY0273.
+
+Every participating DateTime input must carry an offset or `Z`. Otherwise input
+validation rejects the command with Validation **before any rule or condition**,
+even if the comparison would short-circuit or its production would be skipped.
+Targets must enforce this before deserialization attaches a local offset, and
+preserve tick precision or refuse the comparison; JavaScript `Date` alone truncates
+precision. Client validators omit date ordering rules. Optional absent values still
+pass validation rules other than `not empty`; optional condition operands refuse.
+
+PLAY0268 still refuses mixed Date/DateTime, `$context` operands (including
+`$context.occurred`), `today`, protected read paths, date rules on concepts and
+reaction `where`. A refused whole comparison reports only PLAY0268, without
+validating its literals. A `given clock` does not admit `today` or now.
+Stage refuses v26 with STAGE-ESM-016; standalone binding/reference execution is
+not rendering. Preserve the rule and route delivery to authorized gap-fill.
+
+## Retention window and rejection specifications
+
+Two required DateTime inputs express a caller-chosen interval, not the server's
+clock. Keep state-dependent retention-policy reads separately protected; this
+example models only interval ordering. `then` matching remains ordinal, as do
+keys, constraints and freshness: preserve the exact produced payload spelling,
+not a different offset that happens to name the same instant.
+
+```screenplay
+concept WindowId : Uuid
+module Retention
+  feature Windows
+    slice StateChange KeepWindow
+      command KeepWindow
+        windowId WindowId identifier
+        from DateTime
+        to DateTime
+        validate
+          require to >= from
+            message "The window must not end before it starts"
+        produces event WindowKept
+          from DateTime = from
+          to DateTime = to
+      specification AcceptingEqualInstantsWithDifferentOffsets
+        when KeepWindow
+          windowId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          from = "2026-10-01T10:00:00+02:00"
+          to = "2026-10-01T08:00:00Z"
+        then WindowKept
+          for "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          from = "2026-10-01T10:00:00+02:00"
+          to = "2026-10-01T08:00:00Z"
+      specification RejectingAnInvertedWindowByOneTick
+        when KeepWindow
+          windowId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          from = "2026-10-01T08:00:00.0000002Z"
+          to = "2026-10-01T08:00:00.0000001Z"
+        then error "The window must not end before it starts"
+      specification AcceptingAnIncreasingWindow
+        when KeepWindow
+          windowId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          from = "2026-10-01T08:00:00Z"
+          to = "2026-10-01T09:00:00Z"
+        then WindowKept
+          for "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+          from = "2026-10-01T08:00:00Z"
+          to = "2026-10-01T09:00:00Z"
+```
+
+Extract the complete fence into an ignored `.ai-work/` model folder. Run
+`screenplay <folder> --warnaserror --no-color` (zero errors/warnings), then
+`screenplay test <folder>` (all three specifications passed, none Unsupported).
+
+## Missing-offset input rejection
+
+Add a `RejectingAMissingOffset` test at the evaluator-request or target input
+boundary: submit `from = "2026-10-01T08:00:00"` with a valid `to`, then reverse which
+input lacks an offset. Expect Validation before any rule, no facts, and the message
+`DateTime command property 'from' requires an explicit offset or Z.` (or `'to'`).
+Include a skipped-condition case where applicable. A typed `.play` fixture with
+that invalid value refuses binding with PLAY0273; `then error` does not turn it
+into an executed runtime rejection. Record the target test separately, not as a
+passing `.play` specification or a `given clock` workaround.

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-command-surface/references/validate-rules.md

@@ -23,6 +23,16 @@ modifier generates check digits but does not add validation. Check digits catch
 typos, not forgery. For generated-concept proof statuses, deterministic regex
 limits and PLAY0688 repairs, read [generated rules](generated-values-and-responses.md#generated-concept-rules-esm-v20).
 
+## Date and DateTime comparisons
+
+Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`); older binders refuse
+with PLAY0268. Command/property rules admit `==`, `!=`, `>`, `>=`, `<`, `<=` against
+a same-primitive date literal only, for example `to >= "2026-01-01T00:00:00Z"` on
+DateTime. Property-to-property comparisons instead use `require to >= from`.
+Date rules on concepts remain refused; an absent optional value passes rules
+except `not empty`. Read [date comparisons](date-comparisons.md) for UTC ticks,
+input offsets, refused positions and the complete retention-window specifications.
+
 ## `not empty` means non-blank text
 
 On text, `not empty` rejects null, empty text and whitespace-only text; at least
@@ -75,5 +85,5 @@ implementation. Attached command handlers and `file` constraints remain PLAY0268
 Literal text rules, portable patterns and Studio desugaring: [text and match rules](text-and-match-rules.md).
 Stage renders pure reducer transitions and opaque policy bodies, but refuses command and
 concept code validations and rule predicates (STAGE-ESM-005): those are gap-fill code. Prefer a
-declarative rule when one can say it. What binds and what the executable model rejects (Date and
-DateTime comparisons, nested-path rules): `cratis-screenplay-toolchain` `references/executable-subset.md`.
+declarative rule when one can say it. What binds and what the executable model rejects
+(date comparisons outside command positions, nested-path rules): `cratis-screenplay-toolchain` `references/executable-subset.md`.

package/package/corpus/skills/cratis-screenplay-command-surface/verification.json

@@ -4,6 +4,9 @@
   "fixtures": [],
   "assertions": [
     { "kind": "play-compiles" },
+    { "kind": "skill-contains", "value": "require to >= from", "file": "references/date-comparisons.md" },
+    { "kind": "skill-contains", "value": "RejectingAMissingOffset", "file": "references/date-comparisons.md" },
+    { "kind": "skill-contains", "value": "STAGE-ESM-016", "file": "references/date-comparisons.md" },
     { "kind": "skill-contains", "value": "Unsupported (`ImplementationBody`)", "file": "references/described-handlers.md" },
     { "kind": "skill-contains", "value": "including Stub mode", "file": "references/described-handlers.md" },
     { "kind": "skill-contains", "value": "DecisionStateChanged", "file": "references/protected-reads.md" },

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,9 +271,10 @@ 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`, dates and `today` in comparisons, `$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 |
+| 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 |
 | Blocks binding (`PLAY0271`, legacy meaning) | Command reads without protected opt-in and `concurrency`; combined protected reads/concurrency is PLAY0783 |
 | Deferred (`PLAY0269`, information) | Screens, layouts, templates, forms, contributions, UI profiles, themes, behaviors and `on`/`uses` |
 | Metadata only (`PLAY0270`, information) | `domain`, `seed`, `persona`, trigger and other descriptions, and `file` provenance on declarations |

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/SKILL.md

@@ -87,6 +87,16 @@ when these inputs are unsettled; skip answered questions.
 ## Scenario types (decide each per command; detail in `references/scenario-catalogue.md`)
 Decide each of these per command: happy path; rule rejection (one spec per rule, exact pinned `then error`); denial (`given caller` without the policy, `then denied`, one per gated command and query); state violation; duplicate or retry; competing claim; alternative path; ordering; external failure; compensation; evolution; and the view pass. Read [references/scenario-catalogue.md](references/scenario-catalogue.md) ("Scenario types at a glance") for each type's question and usual shape.
 
+For command Date/DateTime ordering, cover increasing and inverted intervals,
+equality across offsets, a one-tick boundary and **each participating DateTime
+input without an offset or Z**. That last case rejects with Validation before rules,
+even if a condition short-circuits or a production is skipped. `then` stays ordinal;
+never replace payload text with an equivalent instant. Read the complete
+[retention-window specifications](../cratis-screenplay-command-surface/references/date-comparisons.md)
+for the compiler prerequisite, admitted positions, refused `today` and Stage's v26
+refusal. Missing-offset runtime coverage needs an evaluator-request or target input
+test: a typed `.play` fixture rejects that value at binding with PLAY0273, before runtime.
+
 For recovery, `when redelivered <Event> to <Reaction>` must select one definitely
 matching effective given and no undecided candidate. It delivers only to the named
 reaction without re-appending the input; `then no events` explicitly checks no
@@ -126,7 +136,8 @@ proved and keep other guarantees as target requirements; recovery cases are in
   opaque source text, not the capture's content key.
 - Format rules belong on a `concept`: give each concept rule representative acceptance,
   rejection and boundary specs once (through one command that carries it), not on every use;
-  never `n/a` automatically. Include a whitespace-only rejection for text `not empty`:
+  never `n/a` automatically. Date/DateTime comparisons are command-only, not concept rules.
+  Include a whitespace-only rejection for text `not empty`:
   this changes outcomes in every ESM version (Requires Screenplay 4.151.0 or later). Unicode/identity boundaries
   and evidence: command-surface `references/validate-rules.md`.
   A business rule gets one rejection spec if an expert could recognize it from its message;

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.
 
@@ -18,8 +18,8 @@ Complete, compiled design-mode model (marina guest berths) showing a coverage ma
 // + `require ... message` and marked NOT enforced in the slice descriptions, with their target
 // named. Binding reports PLAY0271/PLAY0268 for them (expected; Screenplay#129): such a model
 // is design-complete but not binding-ready, and that is reported, never "fixed" by deleting the
-// rules. The past-date rule (`night >= today`) is declarative too: ESM v1 has no runtime date,
-// so binding reports PLAY0268 on it (recorded as blocked, not moved into prose); the rule and its rejection
+// rules. The past-date rule (`night >= today`) is declarative too: `today` has no runtime date
+// value, so binding reports PLAY0268 on it (recorded as blocked, not moved into prose); the rule and its rejection
 // specification stay so the intent executes once a date value exists.
 // Verified: V1 (warnings as errors). V3 binding is blocked by the stored-state and date rules.
 
@@ -36,7 +36,7 @@ module Berths
     authorize IsHarbourOffice
 
     slice StateChange ReserveBerth
-      description "One guest boat per berth per night. OneBoatPerBerthNight declares that two event sources cannot hold the same berth-night; the competing-claim specification pins the loser's rejection after an earlier holder. It neither runs two commands at once nor proves the runtime's index-and-append behaviour under failure: that needs target-level verification. A retried ReserveBerth with the same reservation id is refused by ReserveOnce: the fact occurs once, but the retry is NOT answered with success, so a client that lost the first acknowledgement must treat this rejection as 'already reserved' (idempotent handling is a target decision, recorded as an open question). The night must not be in the past: declared in `validate` (`night >= today`) with its rejection specification. Binding reports PLAY0268 for date comparisons today (ESM v1 has no runtime date value), so this rule is design-complete but blocks V3 until Screenplay supports it."
+      description "One guest boat per berth per night. OneBoatPerBerthNight declares that two event sources cannot hold the same berth-night; the competing-claim specification pins the loser's rejection after an earlier holder. It neither runs two commands at once nor proves the runtime's index-and-append behaviour under failure: that needs target-level verification. A retried ReserveBerth with the same reservation id is refused by ReserveOnce: the fact occurs once, but the retry is NOT answered with success, so a client that lost the first acknowledgement must treat this rejection as 'already reserved' (idempotent handling is a target decision, recorded as an open question). The night must not be in the past: declared in `validate` (`night >= today`) with its rejection specification. Binding reports PLAY0268 for the `today` operand, which has no runtime date value (comparisons between Date or DateTime command properties, or against literals, bind), so this rule is design-complete but blocks V3 until Screenplay supports `today`."
       command ReserveBerth
         reservationId ReservationId identifier
         berth         BerthCode
@@ -99,7 +99,7 @@ module Berths
           boatLength    = 31
         then error "Guest berths take boats up to 24 metres"
 
-      // Declarative past-date rule; binding is blocked for date comparisons (see header).
+      // Declarative past-date rule; binding is blocked for the `today` operand (see header).
       specification RejectingANightInThePast
         given caller
           authenticated