@cratis/pi 7.20.0 → 7.22.0

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/invocation-identity.md

@@ -0,0 +1,84 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Declare the actor behind a reaction invocation
+
+## Contents
+
+- Trusted system identity
+- Checked example
+- Diagnostics and target boundaries
+
+## Trusted system identity
+
+Screenplay 4.125.0 supports one reaction-level line
+`runs as system [role "<Role>" and role "<Role>"]`. Roles are optional, nonempty,
+distinct quoted literals; personas and expressions are not accepted. Put it
+under the reaction, not its trigger or invocation. The declaration selects
+**ESM v10**. Without it, invocations remain caller-less; `given caller` never
+supplies an actor to a reaction.
+
+The reference evaluator authenticates a system principal with exactly the stated
+roles. Claim conditions remain unknown, including under not; a satisfied role
+alternative may allow, but final unknown denies. This is not the caller's audit
+identity and does not invent Arc's system subject claims. The identity covers
+invoked/returned commands across that reaction's triggers, not imperative
+pipeline calls in bodies, direct productions, reads, refusal productions or
+causation. Record the actual least-privilege role, not a prose-only actor or an
+ungated command substituted to make the scenario pass.
+
+## Checked example
+
+This complete model compiled with warnings as errors and its reference scenario
+passed on standalone Screenplay 4.125.0:
+
+```screenplay
+policy Worker
+  require role "Worker"
+module Work
+  feature Processing
+    slice StateChange RecordWork
+      command RecordWork
+        workId String identifier
+        authorize Worker
+        produces event WorkRecorded
+    slice Automation ProcessWork
+      event WorkRequested
+        workId String
+      reaction Processor
+        runs as system role "Worker"
+        when WorkRequested
+          workId
+          invokes RecordWork
+            workId = workId
+      specification ProcessingRequestedWork
+        when append WorkRequested
+          workId = "work-1"
+        then WorkRecorded
+          for "work-1"
+```
+
+## Diagnostics and target boundaries
+
+- PLAY0647: malformed, repeated or misplaced identity, including duplicate/empty roles.
+- PLAY0648: gated invocation without declared identity and without an authorization
+  refusal branch. PLAY0557 instead warns on that refusal branch; it cannot turn
+  an always-denied caller-less invocation into a trusted path.
+- PLAY0649: identity with neither invocations nor an implementation body.
+- C# binding PLAY0650/0651 warns about unused roles or definite authorization
+  denial; opaque/unknown cases are not guessed. `--check privilege` (PLAY0652)
+  reviews whether event producers require every elevated role, not runtime safety.
+
+CLI 3.41.0 bundles Screenplay 4.114.0, which does not parse `runs as`: the example's
+`cratis screenplay validate --executable --warnings-as-errors` returns PLAY0137,
+exit 5. It cannot render this source. Its render version gate separately admits
+only through v7 (CLI-RENDER-004 for newer admitted compiler output), while Stage
+4.51.3's direct planner audits through v7 and refuses v10 with STAGE-ESM-016.
+Clock/application-trigger identities have no Stage Arc realization either.
+Use authorized gap-fill with the model as contract; returned-command Arc identity
+uses `[ExecuteCommandsAsSystem]`, never permission inferred from a model header.
+Refusal/redelivery syntax remains unadmitted even when identity itself runs.
+
+Authority: Screenplay v4.125.0 `reactions.md`, `ReactionIdentityParser.cs`,
+`ReactionRefusalValidator.cs`, `SemanticModelBinder.cs`; CLI v3.41.0
+`RenderedSemanticVersions.cs`; Stage v4.51.3 `SemanticCratisAdmission.cs`.

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/refusals-and-redelivery.md

@@ -0,0 +1,102 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Refusal handling and redelivery intent
+
+## Contents
+
+- Select a refusal
+- Branch values and acknowledgement
+- Redeliver an existing occurrence
+- Recovery boundaries
+
+## Select a refusal
+
+At Screenplay 4.125.0 these forms are authoring-only: binding refuses the whole
+model with PLAY0268, even when the source is valid. Do not execute them as append
+scenarios or silently drop branches. Sources: released `reactions.md`,
+`specifications.md`, decision 0030.
+
+Inside an `invokes` block, ordered selectors state intended recovery:
+
+| Selector | Matches at future admission |
+| --- | --- |
+| `on refused` | Validation or constraint, not authorization |
+| `on refused by validation` | Input/concept/require rejection |
+| `on refused by constraint` | Any constraint rejection |
+| `on refused by constraint <Name>` | One unambiguously resolved applicable constraint |
+| `on refused by authorization` | Unauthorized, never an opaque policy's Unsupported result |
+
+The first matching selector wins. Repeated selectors or narrower branches after
+covering branches report PLAY0540; bare refusal does not cover authorization.
+Unknown named constraints report PLAY0542; known but inapplicable constraints
+also report PLAY0540. Authorization recovery requires a deliberate trusted path,
+not a fictional caller supplied by `given caller`. On current source a declared
+reaction `runs as` affects identity diagnostics, but refusal branches themselves
+remain unadmitted; do not infer their execution from that separate capability.
+
+## Branch values and acknowledgement
+
+A branch contains leaf `acknowledge` alone, or ordinary `produces <Event>` blocks
+with mappings and optional `for`. Empty branches, repeated acknowledgement,
+acknowledgement plus productions, operations, inline events and attachments refuse.
+Acknowledgement states a terminal disposition, not a successful command or fact.
+
+Branch event mappings may use String values `$refusal.reason` (validation,
+constraint, authorization), `$refusal.message` (verbatim details, including symbolic
+localization keys), and `$refusal.constraint` only in constraint selectors.
+Unknown members, wrong scope or incompatible targets report PLAY0541. Messages
+are display details, not stable identity; trigger inputs remain available, read
+aliases do not become branch inputs.
+
+The intended admitted behavior stops remaining invocations of that trigger after
+handling a refusal, but lets other reactions/cascades from accepted facts settle.
+The refused command adds no facts; branch appends obey normal constraints and
+cannot catch their own refusal through another branch. Unhandled refusal retains
+earlier accepted facts. This is a future contract, not passing runner behavior.
+
+## Redeliver an existing occurrence
+
+The complete authoring model below compiles without warnings on 4.125.0;
+`screenplay test` intentionally returns 3/unbound with PLAY0268 for redelivery
+and no-event assertion, not a recovery pass:
+
+```screenplay
+module Billing
+  feature Claims
+    slice Automation Recovery
+      event Approved
+        invoice String
+      reaction Claimer
+        when Approved
+      specification Recovery
+        given Approved
+          for "invoice-1"
+          invoice = "invoice-1"
+        when redelivered Approved to Claimer
+          for "invoice-1"
+          invoice = "invoice-1"
+        then no events
+```
+
+`to <Reaction>` must resolve to one observer of the event (PLAY0544). Optional
+`for`, payload values and stream/no-stream route narrow effective given occurrences;
+exactly one definitely matching occurrence and no unknown candidates are required
+(PLAY0543). Equal duplicate givens are still separate candidates. A locator with
+no route is a wildcard; explicit stream ids compare canonically, and `no stream`
+selects only unrouted givens. This is the sole action, not an extra action after
+append. Intended delivery uses the existing occurrence, never appends it again.
+
+Leaf `then no events` explicitly expects no new facts after a non-append action.
+It may accompany view/query/response assertions, not events, any-order events,
+error or denial. It is invalid after `when append` (PLAY0545), and remains
+unadmitted even on a model without a refusal branch.
+
+## Recovery boundaries
+
+Exceptions, infrastructure/contract errors, Unsupported and concurrency conflicts
+are not refusals. There is no `by concurrency`: transient contention fails/retries,
+not acknowledgement. Ordinary redelivery is not replay. Neither these forms nor
+an observer/occurrence locator prove runtime deduplication, a cascade-wide
+transaction, once-only delivery or exactly-once external effects. Specify the
+actual recovery owner and target enforcement before making those claims.

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/specifying-triggers-and-clock.md

@@ -18,8 +18,10 @@ specification IssuingTheWeeklyDigest
 ```
 
 Under `cratis` before 3.28.2 these actions parsed and were checked against the application
-but bound to nothing (`PLAY0268` names ESM v6, decision 0022); on 3.28.2 they bind. Either way
-no command runs them: report such a specification as authored, not executed. Clock rules: the clock is UTC and exact; an
+but bound to nothing (`PLAY0268` names ESM v6, decision 0022); on 3.28.2 they bind.
+Current standalone 4.125.0 executes admitted scenarios through `screenplay test`
+or MCP `run-specifications`; source compilation alone is authored evidence.
+Clock rules: the clock is UTC and exact; an
 occurrence fires once when it is **due after `given clock` and at or before
 `when clock`**, in time order; intervals count from the Unix epoch; `when clock`
 needs `given clock`, so equal instants fire nothing. Limits: 10,000 occurrences per

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/verification.json

@@ -57,7 +57,7 @@
     },
     {
       "kind": "skill-contains",
-      "value": "Screenplay#383"
+      "value": "ESM v10"
     },
     {
       "kind": "skill-contains",

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

@@ -31,16 +31,12 @@ source is the single flow model.
 | `Cratis.Screenplay` | `4.31.0` | Original examples and executable boundaries |
 | `Cratis.Screenplay` | main `fd18129` | Inline events, repairs and canonical `optional`; changed examples compiled |
 | `Cratis.Screenplay` | `4.66.0` (`c89198b`) | Binding behaviour of `handler`, code attachments, `persona` and compliance attributes: `Semantics/SemanticModelBinder*.cs`, `Diagnostics/DiagnosticCodes.cs` |
-| `Cratis.Screenplay` | `4.68.0` (`79801bf`) | Current pin: generated values and responses (ESM v7): decisions 0025 and 0026, `commands.md`, `Semantics/Versions.cs`, `SemanticModelBinder.CommandProductions.cs` |
+| `Cratis.Screenplay` | `4.68.0` (`79801bf`) | Historical generated-value/response rule probes (ESM v7) |
+| `Cratis.Screenplay` | `4.125.0` | Current source guidance: routes, operations, negation, protected identifiers and pre-generation contexts; released `commands.md`, `operations.md`, `policies.md`, `context.md`, `diagnostics.md` |
 
-The update follows `commands.md`, `events.md`, `types.md`, `diagnostics.md`,
-`mcp/authoring-tools.md` and decision 0023 at that main commit (after v4.52.0).
-Compilation checks syntax and model consistency, not reference execution.
-
-Checked against the Screenplay repository at tag `v4.31.0` (commit `355dffb`):
-`Documentation/screenplay/{commands,constraints,policies,context,concepts,diagnostics}.md`
-and decisions 0001 and 0003 established the original baseline. Changed examples
-use the newer main commit above; do not attribute their verification to the old tag.
+Historical examples/probes retain the table's original versions; current source
+guidance is not a relabeled old execution result. Compilation checks syntax and
+model consistency, not reference execution. Pins: toolchain `references/versions.md`.
 
 "Parses" and "runs" are different claims. The executable profile, and what
 each construct binds to, is in the `cratis-screenplay-model-authoring` language
@@ -84,7 +80,10 @@ renders this from v4.29.0. The executable model still stops at `PLAY0268` for ei
 event source id (`CHR0034`) and `[Encrypted]` on one (`CHR0052`); Screenplay reports
 `PLAY0515` for `@pii` from Screenplay 4.69.1 and for `@sensitive` from 4.84.1, on a
 command identifier, an explicit `for` destination or an event source identifier; earlier
-versions compile it silently and only Chronicle catches it. Keep the stream identity a surrogate `Uuid`
+versions compile it silently and only Chronicle catches it. Current PLAY0515
+also covers scalar stream-id types, composite parts and nested route mapping
+sources. It is a source error, including typed destinations, not a binding-only
+warning. Keep the stream identity a surrogate `Uuid`
 concept and carry the personal value (name, email) as a separate `@pii` property and a
 secret as a `@sensitive` property.
 
@@ -271,6 +270,19 @@ produces when isProForma == true
     for invoiceId
 ```
 
+## Routes and external operations
+
+Named event sources/streams and command routes bind as ESM v8 at 4.125.0;
+CLI 3.41.0 render rejects models above v7. The complete checked route example
+and nested `streamId =` form are in `cratis-screenplay-toolchain`
+`references/sources-and-streams.md`.
+
+Use `system`, `uses` and inline/standalone `operation` declarations to state
+external work in the authored production sequence, with execute/compensate phase
+intent. These remain unadmitted (PLAY0268), not post-commit reactions. Read
+[operation intent](references/operations.md) for forms, boundaries and checked
+failure/compensation specification syntax.
+
 ## `concurrency`
 
 Five dimensions, each at most once, and at most one `concurrency` block per
@@ -292,8 +304,9 @@ to the routed scope. This does not make command `reads` protected.
 
 ## Generated values and responses (ESM v7)
 
-A `generated` property and a `returns` response need standalone `screenplay` 4.68.0; the cratis CLI reports
-`PLAY0268` and Stage refuses them, so such a command is **not rendered yet**: hand-write it.
+Generated values/responses bind as ESM v7, including in the current CLI bundle.
+CLI 3.41.0 admits v7 to Stage planning; its canonical corpus gets generated-value
+and response refusals STAGE-ESM-028/029. Binding is not a render claim.
 Read [references/generated-values-and-responses.md](references/generated-values-and-responses.md) when adding or
 reviewing `generated` properties, `returns` responses, or decision 0023 constructs.
 Read `cratis-screenplay-toolchain/references/generated-responses-example.md` when adding generated command values or response assertions and you need a complete compiled example.
@@ -355,10 +368,9 @@ Four contexts, and **what each omits is load-bearing** — when writing a code b
 
 ## Verify
 
-- [ ] Standalone `screenplay <model> --warnaserror` (4.68.0) reports zero errors and zero
-      warnings; or `cratis screenplay validate --warnings-as-errors` on the model folder
-      (3.28.2 and 3.28.3 bundle Screenplay 4.66.0, ESM v6 at most; before 3.28.2 bundled 4.60.1, ESM v5
-      or lower). Name which tool produced the result.
+- [ ] Validate the complete model root with warnings as errors; name the tool,
+      version and result. Current pins: standalone 4.125.0 / CLI 3.41.0; 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.

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

@@ -50,6 +50,15 @@ time: `CommandAs<T>()`, `ArgumentsAs<T>()`, `ArtifactAs<T>()`, `ValueAs<T>()`, a
 `StateAs<T>()`/`EventAs<T>()` on the reducer context. A payload of another type
 throws `ContextPayloadTypeMismatch`.
 
+At Screenplay 4.125.0, typed contexts before generation (`CommandValidation`,
+`ConceptValidation`, `RulePredicate`, `PolicyPredicate`) expose **input properties
+only**. Generated values exist only after authorization/validation, so they are
+absent from those shapes. A generated identifier's policy subject is `unavailable`,
+not the eventual id; never authorize against it. The handler CommandContext retains
+the full command shape, including generated properties. Sidecars belong to the same
+compilation/revision as their requirements, not a shape borrowed from another model.
+Source: `v4.125.0:Documentation/screenplay/context.md`.
+
 ## The values they carry
 
 | Type | Members |

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

@@ -1,10 +1,13 @@
 ## Generated values and responses (ESM v7)
 
-A `generated` command property and a `returns` response bind and execute from the standalone
-`screenplay` 4.68.0 (ESM v7, decision 0026; `commands.md` "Generated values and responses" at
-`v4.68.0`). The cratis CLI 3.28.3 bundles 4.66.0 and reports `PLAY0268` for them, and Stage 4.24.2
-refuses ESM v7 with `STAGE-ESM-016` (tracked in Stage#201), so a command that uses them is
-**not rendered yet**: hand-write it (gap-fill) with the model as the contract. Complete compiled example:
+A `generated` command property and `returns` response bind and reference-execute
+as ESM v7. Current pins are standalone Screenplay 4.125.0 and CLI 3.41.0
+(bundled Screenplay 4.114.0/Stage 4.51.3); `cratis-screenplay-toolchain`
+`references/versions.md` owns the table. CLI#261 is closed: CLI now admits v7
+to Stage planning, but its v7 canonical corpus receives Stage generated-value
+and response refusals STAGE-ESM-028/029. Do not turn this into a blanket compiler
+refusal or promise a render from binding alone. Preserve the contract for gap-fill
+where admission refuses. Historical rules below were read at 4.68.0. Complete compiled example:
 `cratis-screenplay-toolchain` `references/generated-responses-example.md`.
 
 ```screenplay excerpt
@@ -40,12 +43,11 @@ Rules (all read at `v4.68.0`):
 - Generated values give no idempotency, retry or deduplication guarantee. Specifications supply fixtures and assert
   the response: `cratis-screenplay-specifications`.
 
-Other decision 0023 constructs are still **authorable, never executable** (binding reports `PLAY0268`, so
-they stop a model at V1): operations, and named event sources and streams with command routes
-(`eventsource`, `stream`, `streamId`). **No supported ESM version admits them**, and they have no version number
-yet (decision 0025 numbers a version only at its release-ready admission). Syntax or MCP acceptance is not proof of
-execution. A model using sources, streams or routes can be authored and validated, but
-not bound, run or rendered; hand-write the code with the model as contract
-(`cratis-screenplay-toolchain` `references/sources-and-streams.md`). `derive` and `provide` have no documented syntax at that tag; treat them as
-planned and do not write them.
+Operations remain authorable/unadmitted (PLAY0268). Named event sources,
+streams and command/specification routes instead bind and reference-execute as
+ESM v8 at 4.125.0; CLI 3.41.0 render refuses versions above v7 before planning
+(CLI-RENDER-004). Syntax/MCP acceptance alone is not execution. Source/stream
+forms and realization boundary: `cratis-screenplay-toolchain`
+`references/sources-and-streams.md`. Do not infer further syntax or provider
+admission from decision numbers.
 

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

@@ -0,0 +1,80 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Systems and operation intent
+
+## Contents
+
+- Declare and produce
+- Phases and ordered work
+- Specification intent
+
+## Declare and produce
+
+A top-level `system` names an external business system. A slice-owned `operation`
+declares exactly one `uses <System>`, typed inputs, optional description and
+execute/compensate phases. Operations and their specification steps are
+**authoring-only** at Screenplay 4.125.0: compile acceptance is not execution;
+binding refuses the whole model with PLAY0268. Source: released `operations.md`.
+
+`produces operation <Name>` declares an inline slice-owned operation with typed
+input mappings. Plain `produces <Name>` references an existing event or operation;
+it never creates one from a typo. Event and operation names share resolution:
+collisions/ambiguity refuse, not event-first guessing. Standalone operation
+references can be qualified across slices; that does not broaden event-production
+grammar. Operations are produced by commands, not reactions, and take no `for`,
+tags or event routing metadata. Inputs cannot be identifier/generated properties.
+
+## Phases and ordered work
+
+Keep mixed event/operation productions in their authored sequence. The intended
+future transaction contract enrolls events first, executes operations in authored
+order before commit, and compensates according to commit disposition. It does
+not promise reverse compensation order, rollback or post-commit delivery.
+
+Each phase accepts a description and one direct file/tagged body or an
+`implementation` wrapper with ordered nonblank hints and optional source.
+Direct/wrapped sources cannot mix; duplicate phases/payloads refuse.
+Description-only/hints-only phases are pending intent, not executable code.
+Typed `execute Type` remains an input; bare `execute` opens a phase. Escape an
+input named uses as `@uses`, and event-metadata input names where needed.
+No automatic operation extraction ships: moving an inline declaration manually
+must preserve its production sequence, mappings, comments and attachment paths.
+
+## Specification intent
+
+This complete authoring-only model compiles with `--warnaserror` at 4.125.0.
+`screenplay test` intentionally returns exit 3/unbound with PLAY0268; it proves
+no failure/compensation behavior today:
+
+```screenplay
+system Accounting
+concept ProjectId : Uuid
+module Projects
+  feature Registration
+    slice StateChange Register
+      operation OpenCostCenter
+        uses Accounting
+        projectId ProjectId
+        execute
+          description "Open a provisional cost center"
+        compensate
+          description "Close it if registration does not commit"
+      command RegisterProject
+        projectId ProjectId identifier
+        produces OpenCostCenter
+          projectId = projectId
+      specification Compensating
+        given operation OpenCostCenter fails
+        when RegisterProject
+          projectId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+        then operation OpenCostCenter
+          projectId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+        then compensated OpenCostCenter
+```
+
+`given operation ... fails` and `then compensated ...` are leaves. A requested
+`then operation` can state a partial input subset, with unique fields and
+compatible concrete values. References resolve against declared operations;
+compensation intent needs a declared compensate phase. Provider execution is a
+separate future admission, never implied by a source fixture.

package/package/corpus/skills/cratis-screenplay-command-surface/references/policy-persona-seed.md

@@ -20,7 +20,7 @@ persona Accountant
   policy IsAccountant
 ```
 
-Three condition forms: `authenticated`, `role "<name>"`, and
+Condition atoms: `authenticated`, `role "<name>"`, and
 `claim "<name>" matches subject | "<value>" | <path>`. A policy has **exactly one**
 `require` line — continue the condition on deeper-indented lines instead of adding
 a second (`PLAY0441`) — **or** one implementation (a tagged ` ```csharp ` block or
@@ -29,6 +29,28 @@ runner; a code policy binds as opaque ESM v3 and needs a target to evaluate it.
 A `persona` is authoring metadata: the binder reports it as information `PLAY0270`
 (report-only) and it does not block binding; an unknown policy it lists is an error.
 
+## Policy negation
+
+At Screenplay 4.125.0, `not <condition>` is a portable ESM v7 policy-condition
+form (decision 0027), not a named-policy operator in `authorize`. It can negate
+atoms/groups, not an opaque inline/file implementation. Precedence is `not`,
+then `and`, then `or`; parentheses override grouping. Double negation restores
+a known value, not an unknown target.
+
+Missing caller claims compared to a known text target have no match (false),
+so their negation is true. A missing/null/non-text comparison target or absent
+subject is instead **unknown**. `not unknown` stays unknown; final unknown denies.
+Kleene combinations preserve known decisive values: true OR unknown is true,
+false AND unknown is false; false OR unknown and true AND unknown stay unknown.
+`not role "Service"` alone does not require authentication: retain an explicit
+`authenticated` condition when a signed-in caller is required.
+
+Opaque predicates reached in authored short-circuit order return unsupported,
+never false or permission under negation. Binding warns with PLAY0546 when a
+negated claim's target is optional, non-string, or a subject without a command
+identifier. This C# semantic check does not come from ordinary editor validation.
+Source: `v4.125.0:Documentation/screenplay/policies.md`.
+
 ## `seed`
 
 Excerpt: `CustomerRegistered` is declared in a slice.

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

@@ -75,13 +75,13 @@
     },
     {
       "kind": "skill-contains",
-      "value": "No supported ESM version admits them", "file": "references/generated-values-and-responses.md"
+      "value": "streams and command/specification routes instead bind and reference-execute as", "file": "references/generated-values-and-responses.md"
     },
     { "kind": "skill-contains", "value": "Generated values and responses (ESM v7)" },
     { "kind": "skill-contains", "value": "A generated value is not a request input", "file": "references/generated-values-and-responses.md" },
     { "kind": "skill-contains", "value": "(`PLAY0273`), and a concept with any validation rule cannot back a\n  generated property (`PLAY0268`)", "file": "references/generated-values-and-responses.md" },
     { "kind": "skill-contains", "value": "A response exists only on acceptance", "file": "references/generated-values-and-responses.md" },
-    { "kind": "skill-contains", "value": "**not rendered yet**", "file": "references/generated-values-and-responses.md" },
+    { "kind": "skill-contains", "value": "STAGE-ESM-028/029", "file": "references/generated-values-and-responses.md" },
     { "kind": "skill-contains", "value": "4.68.0" }
   ]
 }

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

@@ -48,7 +48,8 @@ Statements here were checked at those tags:
 
 | Fact used here | Source |
 | --- | --- |
-| Persona syntax, report-only, policies must be declared, `description` first and once | Screenplay `v4.66.0:Documentation/screenplay/personas.md` |
+| Persona syntax, report-only, policies must be declared | Screenplay `v4.66.0:Documentation/screenplay/personas.md` |
+| Description order; authored/import board order and order-preserving MCP layouts | Screenplay `v4.125.0:Documentation/screenplay/grammar.md`, `folders.md`, `imports.md` |
 | Single-line and fenced `description` (`FencedText`) | `v4.66.0:Documentation/screenplay/slices.md#descriptions`, `grammar.md:1084-1088` |
 | `<Type>[]`, shapes must be declared; `@pii` and `reason` on concepts | `v4.66.0:Documentation/screenplay/events.md`, `concepts.md` |
 | `then denied`, `given caller`, `then error` | `v4.66.0:Documentation/screenplay/specifications.md` |
@@ -136,12 +137,14 @@ decided apart from what you assumed. Never guess silently.
 - Slice types are a closed set: `StateChange`, `StateView`, `Automation`, `Translate`. In
   discovery an event lives in the `StateChange` slice that will produce it, named after the
   probable command; a slice with only an `event` compiles.
-- A `persona` names declared policies only (unknown policy = error); `description` is the
-  first body line and appears once.
+- A `persona` names declared policies only (unknown policy = error); `description` appears
+  at most once, anywhere in its body.
 - Declare each event once in the whole application; other slices refer to it by name.
-- Folder-layout round-trips re-sort modules, features and slices by name (a single document
-  keeps authored order at v4.66.0): story order is documentation (feature `description`,
-  STATE.md), never structure.
+- Boards keep authored declaration and import order: imports expand depth-first, glob
+  matches alphabetically. Unimported folder files remain visible after ranked siblings.
+  MCP `expand-layout` preserves this order with import barrels; an import-less
+  `PlayFileWriter.Expand` layout falls back to path order. Order is presentation, not
+  execution or identity. Keep causes and branches in the feature `description` and STATE.md.
 - A misspelt keyword inside a slice is only warning PLAY0029 and the block disappears: always
   validate with warnings as errors.
 

package/package/corpus/skills/cratis-screenplay-discovery/references/storming-loop.md

@@ -29,7 +29,7 @@ then reports what changed and asks one question. The user should always be able
    | rename | better business name for an existing fact | identity-affecting once persisted: see SKILL.md |
    | split | one name was covering two facts | keep the original if it is persisted; add the second |
    | merge | two names for one fact | only when they truly mean the same thing |
-   | reorder | the story order changed | update the feature `description`/STATE.md; files sort by name |
+   | reorder | the story order changed | change declaration/import order for the board; update the feature `description`/STATE.md for causes and branches |
    | drop | not a fact after all | record why in STATE.md |
    | none | already modeled | say so briefly |
 
@@ -65,10 +65,11 @@ open, start the sweep (`divergent-sweep.md`).
 ## A discovery skeleton
 
 What a model looks like after the first workflow has been stormed: no commands, read models
-or screens yet. Slices are named after the command expected to produce each event and are
-sorted by name when a folder layout is written back (a single document keeps authored order
-at v4.66.0), so the order of the story lives in the feature `description`, not in position. Persona
-`description` text holds Does / Reads / Cannot on one quoted line here; the multi-line fenced
+or screens yet. Slices are named after the command expected to produce each event. At
+Screenplay 4.125.0, boards use authored declaration/import order, and MCP `expand-layout`
+preserves it with imports. An import-less `PlayFileWriter.Expand` layout still falls back to
+path order. Order is presentation only; the feature `description` records causes and branches.
+Persona `description` text holds Does / Reads / Cannot on one quoted line here; the multi-line fenced
 form is in `personas-and-causes.md`.
 
 ```screenplay

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

@@ -134,11 +134,13 @@ What binds depends on **which tool** you ask, so name the tool and its version:
 - `persona` declarations are report-only and never block; `@pii` and `@sensitive`
   concepts do block binding (`PLAY0268`). Keep them anyway: the classification is
   part of the model. Report the block.
-- Generated values and `returns` responses bind and execute from standalone 4.68.0 (ESM v7) but fail binding
-  with `PLAY0268` on the 4.66.0 bundled in `cratis` 3.28.x, and Stage 4.24.2 does not render them
-  (`STAGE-ESM-016`, tracked in Stage#201): gap-fill. Operations and systems, and event sources and
-  streams, are authorable but non-executable (`PLAY0268`; not admitted by any supported ESM version);
-  a command `handler` never binds.
+- Generated values/responses bind and reference-execute as v7; sources, streams
+  and command/specification routes as v8; reaction `runs as` identity as v10 on
+  standalone 4.125.0. Use `screenplay test` or MCP `run-specifications` for V4.
+  Operations/systems, exact numbers and refusal/redelivery remain unadmitted.
+  CLI 3.41.0 bundles older syntax and renders through v7 only: its parser rejects
+  `runs as`, and Stage refuses generated values/responses with STAGE-ESM-028/029.
+  Source/binding admission and target realization are separate gates.
 
 The ESM versions, the full disposition table and the Step 7 clock example's binding
 result are in [references/parsed-not-runnable.md](references/parsed-not-runnable.md)

package/package/corpus/skills/cratis-screenplay-event-modeling/references/nine-steps.md

@@ -32,8 +32,8 @@ module Invoicing
     description "Registering and managing the lifecycle of invoices"
 ```
 
-`description` is the optional **first body line** of a module, feature, slice,
-persona or command; at most one. Use a fenced block tagged ` ```text ` when one line
+`description` is optional on a module, feature, slice, persona or command;
+at most one, anywhere in its body. Use a fenced block tagged ` ```text ` when one line
 is not enough (a bare fence warns with `PLAY0397`).
 
 ## Step 2 — Brainstorm events
@@ -59,9 +59,10 @@ Phase skill: `cratis-screenplay-discovery`.
 Arrange into the timeline — the plot. *"What happens first? And then what
 happens?"* Identify the happy path **and** the alternative and error paths.
 
-**Output:** the order the slices will be written in. A folder round-trip sorts
-modules, features and slices by name, so the timeline is documentation, not
-structure.
+**Output:** the authored declaration/import order for the board, with causes
+and branches documented. Screenplay 4.125.0 MCP layouts preserve this presentation
+order with imports; an import-less `PlayFileWriter.Expand` layout uses path order.
+Timeline position does not impose execution order or change identities.
 
 ## Step 4 — Create wireframes