Stage (Release v4.77.0): Stage admits exact ESM v13 language/semantic pairs (Screenplay 4.141.0) in the renderer, the Host runtime and the specification executor. Later and mixed versions are still refused with STAGE-ESM-016. (#345)
Stage (Release v4.77.0): Generated concepts carry their compliance from the model: personal data renders [PII] (also when the concept is a secret too), and a secret renders [Encrypted] with its scope plus [NotAudited]. [ComplianceDetails] is not emitted from the executable model. (#345)
Stage (Release v4.77.0): Command inputs that contain personal-data or secret concepts, directly or inside collections, optional values and nested types, render [property: NotAudited], so their values stay out of the causation chain. (#345)
Stage (Release v4.77.0): STAGE-ESM-040 refuses personal-data or secret concepts used as identities (command and read-model identifiers, event destinations, projection, join and child keys, event-source and stream identifier types) and on enumeration concepts. (#345)
Screenplay (Release v4.142.0): propose-property can add a property along its chain with action: "add": name the owning declaration, the type, whether it is optional, and the hops that add the property to other declarations or map it in a produces, from or append block. A projection that AutoMaps the same name needs no hop. Producers or projections left without a mapping refuse with SourcesRequired, and a required property needs a fixtureValue for every existing specification and example occurrence, or the proposal refuses with FixtureValueRequired. Adding to an event needs newGeneration or eventNeverPersisted, as rename and remove do (#389)
Arc (Release v22.77.0): The Screenplay generator reports SP0071 when a reactor executes a command and handles its outcome in code (reading, matching or discarding the CommandResult), and SP0072 when a reactor recovers from redelivery through ReactorDelivery receipts, instead of keeping its file reference without saying why. (part of #3094)
AI (Release v7.35.0): A product sync ledger (.cratis/ai/product-sync.json) records, for each Cratis product, the release the corpus was last synced to and the skills and rules that depend on it; verification keeps it complete and well formed (#619)
AI (Release v7.35.0): A drift report (yarn workspace @cratis/ai-verification run drift) and a weekly workflow keep one “AI corpus product drift” issue up to date with the releases not yet read into the corpus; private repositories without access are listed as not checked, and an optional PRODUCT_DRIFT_TOKEN secret lets the workflow check them
AI (Release v7.35.0): New skills: cratis-arc-hosting, cratis-chronicle-hosting, cratis-chronicle-decision-reads, cratis-arc-testing-kotlin, cratis-arc-identity-and-tenancy-kotlin and cratis-arc-spring-data-kotlin
AI (Release v7.35.0): Experimental Go guidance: cratis/language/go, cratis/engineering/go, cratis/chronicle/client-go and cratis/arc/go profiles with Go rules and skills for Chronicle.Go 0.9.1, Arc.Go 0.1.1 and Fundamentals.Go 0.3.2 (part of #479)
AI (Release v7.35.0): An elixir.md language rule, so the Elixir language profile carries guidance
AI (Release v7.35.0): The Screenplay skills teach propose-property rename and remove (Screenplay 4.140.0) (part of #597)
AI (Release v7.35.0): Specification examples typed by an event, command or read model imported from another document, with PLAY0520 (#604)
AI (Release v7.35.0): The auth skill names AuthProxy and its header contract; the application profile points to dotnet new cratis templates; the C# rules name the Cratis architecture analyzers (CRARCH)
Chronicle (Release v19.51.0): ChronicleFixture.UsesPerContextMongoDBHost in Cratis.Chronicle.XUnit.Integration: an in-process MongoDB fixture that opts in starts a fresh host for every test context and gives its databases a unique prefix, so writes a previous context’s kernel flushes after shutdown cannot change the next context’s results. It defaults to false; a fixture that overrides GetStorageConfigurator passes DatabaseNamePrefix to WithMongoDB. See the integration tests guide.
Arc (Release v22.76.0): The Screenplay generator keeps the integer identity of every enum member. Each member is written with its number (pending = 0, granted = 3, declined = 6), so sparse, negative and reordered enums keep their stored values, and documents with plain positional enums also show their numbers. Non-positional numbers need ESM v12; under a MaximumExecutableModelVersion cap below v12, or for numbers outside int32, the members fall back to positions and warning SP0068 says so. Members that share a number keep the one scenario values resolve to, and warning SP0069 names the dropped aliases. See Generating a Screenplay. (#3175)
Arc (Release v22.76.0): Warning SP0067 reports a [Flags] enum whose unnamed member combinations cannot be stated in the model, naming the enum and the properties that use it. Member names are emitted as before. (#3132)
Screenplay (Release v4.141.0): Concept compliance markers (pii, pii special <category>, pii criminal, secret, secret scope subject|namespace|global) bind into the executable model as ESM v13, as an optional compliance member on the concept that applies wherever the concept is used (part of #141)
Screenplay (Release v4.141.0): Only models that use a marker select ESM v13; models without markers keep their exact executable-model bytes and revision (part of #141)
Screenplay (Release v4.141.0): ESM v13 golden vector and concept compliance canonical corpus for consumers to verify against (part of #141)
Screenplay (Release v4.141.0): Concept documentation on when to mark a concept as personal data or a secret, when not to, the refusals below and how to test a protected model (part of #141)
Screenplay (Release v4.140.0): propose-property plans a rename or removal of explicitly selected command, current-event and read-model properties in one reviewable proposal. It updates proven references, preserves AutoMap relationships, and refuses removal while readers remain. Removing an example value that a then step inherits is disclosed with weakensAssertion: true; when those steps cannot be determined, the removal is refused instead. Review the retained proposal before applying it (part of #389)
Screenplay (Release v4.140.0): Event-property edits require newGeneration or eventNeverPersisted. The proposal reports every selected event’s revision pair and mode in an ordered generations array, preserves historical generations, and discloses in-place edits. New generations require transformations before deployment to Chronicle (part of #389)
Stage (Release v4.76.0): Stage admits exact ESM v12 language/semantic pairs (Screenplay 4.139.0) in the renderer, the Host runtime and the specification executor. Later and mixed versions are still refused with STAGE-ESM-016. (#296)
Stage (Release v4.76.0): Enum members with explicit numbers render as Member = N in every generated C# enum, including sparse and negative numbers; -0 renders as 0. Unnumbered enums render exactly as before. (#296)
Arc (Release v22.75.0): The Screenplay generator now keeps a reactor’s execution identity and observation scope. [ExecuteCommandsAsSystem] becomes runs as system with its exact roles, and [FromEventSource<T>], [EventSourceType] and [EventStreamType] become from Source or from Source.Stream, also when the handler body stays code. Observer-only event source and stream declarations are emitted from their actual definitions. Invalid roles report SP0064, event results with explicit append routing stay code with SP0065, and a model version cap below ESM v10 withholds the new directives with SP0066 while keeping event-only produces bodies. See Generating a Screenplay. (#3156)
AI (Release v7.34.1): Corpus verification fails when a current Stage scaffold or Arc.Screenplay pin is restated outside the central version tables, unless the occurrence is listed with a reason; a listed occurrence that no longer exists also fails (#616)
AI (Release v7.34.0): A cratis-screenplay-delivery-planning skill: plan and estimate delivery of an accepted Screenplay model by slices, run independent slices in parallel along their event contracts, and estimate from the team’s own throughput (part of #611)
AI (Release v7.34.0): New method references adapted from agentic-engineer: a model inventory report, a core-rules card, derived-condition events, screen patterns, a domain analysis template, a slice delivery checklist for reactors and view lifecycle checks for read models (part of #611)
AI (Release v7.34.0): The legacy extraction, render and review skills teach the released cratis screenplay conform drift check, cratis render --scope and --check, cratis screenplay validate --executable, the MCP propose-move refactoring and the --check field-origins, event-consumers and personas rules (part of #611)
Arc (Release v22.73.0): [ReadModel(RequireQueryAttribute = true)] lets a read model expose only methods marked [Query], keeping reduction methods and private, internal or public helpers out of its endpoints and generated proxies. The setting defaults to false, preserving existing conventional query discovery. Adding [Query] alone does not change discovery of sibling methods. (#3163)
Arc (Release v22.73.0): ARC0026 and runtime validation report invalid query markers and ambiguous selected query names. Unmarked helpers on an opted-in read model are not subject to query-signature diagnostics. (#3163)
Arc (Release v22.73.0): ARCCHR0019 warns when a conventional read model contains a likely event-fold method that would become a query. Its previewable code fix opts the type into marked queries, supports editable partial declarations, and refuses migrations that would introduce compilation errors or require editing generated declarations. (#3163)
AI (Release v7.33.0): The Screenplay skills teach explicit enum member numbers (draft = 1, Screenplay 4.137.0): the all-or-none int32 rule, diagnostics PLAY0667 to PLAY0671, the enum-pinning check and the propose-number-enum-members refactoring, and when numbering is worth it (#605)
AI (Release v7.33.0): The skills teach ESM v12 (Screenplay 4.139.0), where non-positional numbers travel as a canonical numbers array beside values, and that the current Cratis CLI and Stage do not admit v12 yet (#605)
AI (Release v7.33.0): The model-authoring skill teaches property-level find-references and dependencies (kind: "Property", Screenplay 4.138.0): addressing members and historical generations, the evidence roles, and reading complete: false as unfinished evidence rather than “no references” (part of #597)
Stage (Release v4.75.0): The renderer, semantic Host and specification executor now explicitly admit Screenplay ESM v11’s exact-number literal contract. Precision-sensitive non-route literals, including the safe-integer bounds ±9007199254740991 and fractions such as 0.10000000000000002, retain their semantic values through generated long/decimal code and execution. Existing v1–v10 and route-only contracts remain unchanged; this does not introduce arbitrary precision or exact source mode. (#331)
AI (Release v7.32.0): Screenplay extraction guidance explains Arc 22.70.0’s secret-scope recovery, SP0061–SP0063 classification diagnostics, and compiler-upgrade self-checks so generated models preserve protection and make losses explicit (#609)
AI (Release v7.31.0): The Chronicle .NET client and event-type-migration skills teach opt-in pinned generation delivery (ChronicleOptions.EventGenerationDelivery = EventGenerationDelivery.Pinned, Chronicle 19.41.0 for reactors and reducers, 19.48.0 for typed materialized projections): what each observer receives, the one-generation-per-event-identifier rule and its registration errors, which projections stay in Compatibility mode, how bare event names in a saved projection definition resolve to a pinned generation, and why scenario tests do not prove generation delivery (#607)
Stage (Release v4.74.0): Render server-generated UUID concepts as Arc generated-value parameters, with deterministic scenario pins and fresh values in the live runtime. (part of #175)
Stage (Release v4.74.0): Render scalar and named command responses and carry accepted responses through the runtime to Scene. (part of #175)
Arc (Release v22.72.0): Reactors can return a sequence mixing events, EventForEventSourceId envelopes and commands. Events append before commands run in order; append rejection prevents command execution, and the first failed command stops the remaining commands. Explicit event routes are preserved. Earlier effects remain committed if a later command fails, so retries require idempotent effects. (part of #3156)
Arc (Release v22.71.0): Response value handlers can declare server-consumed values by attribute using ICommandResponseValueHandlerForAttributed<TAttribute> for scalars and ICommandResponseValueHandlerForAttributedEnumerable<TAttribute> for reference-element enumerables. Chronicle’s event handlers use these declarations. (#2885)
Screenplay (Release v4.139.0): ESM v12 carries explicit enum member numbers, preserving sparse and negative int32 identities alongside member names. Non-positional numbers select v12; enums pinned to their existing positions retain their previous model version and bytes. Specifications continue to use member names. Consumers must admit v12 explicitly. (#643)
Screenplay (Release v4.139.0): Strict model reading and validation reject enum numbers in older versions, duplicate or out-of-range numbers, mismatched member lists and non-canonical positional arrays. (#643)
Stage (Release v4.73.0): A screen records where it sits as Scene’s Screen.Path: the modules and features, outermost first, it was declared in. A module’s own contribute to reaches every screen beneath the module, and a contribution records the hierarchy it was declared in, whether it sits on a module, a feature at any depth or a screen. (part of #237)
Stage (Release v4.73.0): A navigation entry’s id, icon, presentation, group and destination outlet|dialog|external reach the runtime, composed with its navigate to into one Scene destination. The menu honours presentation (icon, text or both), and an entry that opens an outlet or a dialog is executed by the Scene host. (part of #237)
Stage (Release v4.73.0): A toolbar item carries the destination it opens - the screen a navigate item targets, the dialog template a dialog item targets - with its parameters as route parameter bindings, so it runs through the Scene host like any other navigation. Command items render as the Stage’s command action. Presentation hints are honoured (mode of icon, text or both; any other hint is a data-scene-presentation-<name> attribute). (part of #237)
Stage (Release v4.73.0): A screen no navigation entry lists is shown under its own module and feature, with the breadcrumb leading to it, instead of a single “Other screens” group. (part of #236)
Stage (Release v4.73.0): A dialog opened through the host is a real modal: a backdrop above the shell, aria-modal, and Escape closes it. Before, it rendered unstyled at the end of the page where the shell’s sidebar covered its Close button - found by the browser proof. (part of #237)
Stage (Release v4.73.0): The Stage’s core:outlet renders the screen the host placed in the named outlet inside the Stage’s data scope. (part of #237)
cli (Release v3.52.0): cratis render --package-set <FILE> takes an approved package set (the Scene document Stage and a React host share) naming custom runtime packages beyond core, scene.web and Cratis.Components. The profile is resolved against the shipped and the approved packages together with Stage’s planner (CLI-RENDER-007 to CLI-RENDER-010), a malformed set or one that reuses a shipped package name is refused before anything is published, and the published application gets approved-packages.json, one extra package.json dependency per package and a .frontend/approvedPackages.ts that loads them through Scene before the first render. See Custom runtime packages. (part of #284)
cli (Release v3.52.0): The packed-CLI rendered-React check approves a custom package (Integration/Cli/RenderedReact/CustomPackage), renders a screen that names its component, builds and launches the application and asserts in a browser that the component rendered from the package with its style sheet and no load diagnostics. (part of #284)
Screenplay (Release v4.138.0): find-references and dependencies accept kind: "Property" for a command, event or read-model property, addressed as its owner’s address plus the member name (owner.generationN.member for a historical event generation). Results list every place the property flows: mappings, AutoMap, conditions and keys, screen and form bindings, specification fixtures and assertions, and opaque code. A reader that cannot be resolved is reported with its location and marks the result incomplete instead of being left out (part of #389)
Screenplay (Release v4.137.0): Enum members can carry explicit numbers, draft = 1, so a stored enum keeps its numbers when members are reordered or inserted. Numbers are whole int32 values, unique within the enum, and either every member has one or none does. -0 prints as 0. Enums without numbers keep their positional meaning, and enums numbered by position compile exactly as before. Numbers that differ from positions are not admitted by any supported executable model version yet; binding refuses them until a later release admits them. See https://github.com/Cratis/Screenplay/blob/main/decisions/0065-explicit-enum-member-numbers.md (part of #643)
Screenplay (Release v4.137.0): New diagnostics: PLAY0667 (mixed numbering), PLAY0668 (duplicate number), PLAY0669 (number outside int32) and PLAY0670 (malformed number). They are reported by both compilers and the editors. (part of #643)
Screenplay (Release v4.137.0): The MCP refactoring propose-number-enum-members numbers every member of an unnumbered enum by its current position. The opt-in completeness check enum-pinning (PLAY0671) suggests it for unnumbered enums used by event properties. (part of #643)
Stage (Release v4.72.0): CratisRendering.CreateProfile(..., approvedPackages) carries an approved package set in the render profile as approved-packages.json and generates the frontend that installs and loads it: one extra package.json dependency per package, .frontend/approvedPackages.ts (literal imports, package style sheets, loadApprovedComponents() over Scene’s loadApprovedPackages) and a main.tsx that awaits it before the first render. An application with no approved packages plans byte-for-byte what it planned before. Admission regenerates the whole frontend from the document and refuses a profile that differs (STAGE-CRATIS-001). See Custom runtime packages. (part of #236)
Stage (Release v4.72.0): CratisRendering.ShippedPackages, ShippedPackageNames and CatalogWith(set): the catalog a ui profile resolves against is the packages the target ships plus the approved ones, so an approved package’s layouts, themes, dependencies and version ranges are checked by the same planner. (part of #236)
Stage (Release v4.72.0): CratisBackendApplicationScaffoldRequest.WithApprovedPackages refuses a package that reuses a shipped package name or an npm package the scaffold already installs. (part of #236)
Stage (Release v4.72.0): The Stage App takes a packageCatalog, so an authored component Acme.Charts.chart (or a bare name only an approved package declares) resolves to the key the package registers its component under instead of rendering “Unresolved component”. (part of #237)
Scene (Release v4.21.0): Screen.path (Screen.Path in .NET): the modules and features, outermost first, a screen was declared in. A destination’s module/feature identity resolves against it and a host can group an unlisted screen by it. (part of #74)
Scene (Release v4.21.0): NavigationItem.hierarchy (NavigationItem.Hierarchy in .NET): the modules and features a navigation contribution was declared in. (part of #74)
Scene (Release v4.21.0): core:toolbar and core:toolbarItem in the core package. An Action item announces its command with its parameters resolved; Navigate and Dialog items execute their destination through the Scene navigation host (a screen in an outlet, a dialog) and are announced with cratis.scene.navigate outside one. presentation is honoured: mode is icon, text or both, and every hint is exposed as data-scene-presentation-<name>. See the application hierarchy and toolbars. (part of #74)
Stage (Release v4.71.0): Rendered read-model and query specifications whose givens are routed now render and run, where they used to be refused with STAGE-ESM-030. Each given is seeded on its own event source, stream type and stream identity through ReadModelScenario, so a reducer filtered to a source or stream replays exactly the facts it would see in production. (#327)
Stage (Release v4.71.0): A navigation contribution’s group is carried into the Scene output. (#327)
Scene (Release v4.20.0): ApprovedPackageSet / ApprovedPackageSetJson (Cratis.Scene.Engine): the approved package set document (manifest + module per package). Read validates it - unknown members, document version, names the host already ships, duplicates, icon libraries, invalid npm names/exports, URL or foreign style sheets - and Catalog gives planning the manifests without loading code; Write is canonical. See Approved package sets. (part of #75)
Scene (Release v4.20.0): loadApprovedPackages and resolveApprovedPackageHost (@cratis/scene.react): load the set’s bundles through an explicit map of literal import()s, only when the host policy allows executable imports, refuse a bundle that differs from its declaration, and block the host with a diagnostic when a package is missing, fails to import or lacks its export. Packages load in ordinal name order. (part of #75)
AI (Release v7.30.0): The Screenplay skills teach ESM v9 public events and translation direction: public event, event X from "store", direction inbound|outbound on Translate slices, outbound projections and reducers that target a public event, and inbound source events captures, with imports of public or foreign events still refused with PLAY0268 (#567)
AI (Release v7.30.0): The toolchain skill lists the public-event and translation diagnostics PLAY0607–PLAY0620 with their repairs (#562)
AI (Release v7.30.0): The Screenplay skills teach ESM v10 read-model key modifiers and by blocks, per-production stream route overrides and observer from filters with PLAY0660–PLAY0666, state that composite keys still bind with PLAY0268, and describe exactly how a read model’s identity is chosen when no key is marked (#580)
Chronicle (Release v19.48.0): Projections can opt in to read every event in the generation each of their clauses handles, on live delivery, catch-up and replay alike. The kernel selects, decrypts and, when needed, migrates the event to that generation for From, joins, children, keys and removals. Projections registered from a .NET client with ChronicleOptions.EventGenerationDelivery set to EventGenerationDelivery.Pinned opt in; other projections are unchanged. See event type migrations (part of #4710)
Arc (Release v22.69.0): QueryScenario.Observe(...) subscribes to an observable or IAsyncEnumerable<T> query and returns a QueryObservation. Initial is the first result, and Next(timeout) waits for the next one. Results are buffered from the moment of subscription, so a specification never has to sleep, and each result goes through read-model interceptors and emission guards the same way it does over SSE and WebSocket. (#3153)
Arc (Release v22.69.0): Documentation for observable queries in QueryScenario, including the limits: a result from Next is the next emission, not the next distinct value, and MongoDB .Observe() queries need a real database. (#3153)
Stage (Release v4.70.0): Keyed absence assertions for admitted read-model projections pass only when the specified instance is missing; instances at other keys do not affect the result. (part of #15)
Stage (Release v4.70.0): Protected optional snapshot queries by read-model identifier evaluate portable authorization policies using the specification’s caller, query argument and key as the subject. Denials match then denied, not an empty result or then error; reached opaque policies remain Unsupported(Authorization). (part of #15)
Chronicle (Release v19.47.0): The .NET client logs what it discovered at startup: totals per artifact kind at Information, and the ids of each kind at Debug. The same report is available as IEventStore.Discovery. (#4733)
Chronicle (Release v19.47.0): Before registering, the .NET client compares its artifacts with what the event store already holds and flags likely renames or moves. A renamed reactor is a Warning, because its new id makes it catch up from the start and re-run its side effects, which [OnceOnly] does not prevent. A renamed reducer or projection is Information. An event type whose id is new but whose schema matches exactly one existing event type is a Warning. Findings are also available as Registration.IdentityDrift. (#4733)
Chronicle (Release v19.47.0): ChronicleOptions.ArtifactIdentityDrift chooses what happens on a finding: Warn (the default) logs and continues, Fail stops registration with ArtifactIdentityDriftDetected for reactor and event-type findings, and Ignore skips the check. If the event store cannot be reached for the comparison, registration continues as before. (#4733)
Chronicle (Release v19.47.0): Documentation on reactor identity: give side-effecting reactors an explicit id with [Reactor("…")], and remove orphaned observers with Observers.Remove. (#4733)
Screenplay (Release v4.134.0): SemanticExecutionPlan.Compile(model, selectedSlices) compiles an execution plan for a selection of slices. The plan keeps the original model and revision. Admission issues in the selected slices and in application-level declarations block it. Issues in unselected slices are reported in UnselectedIssues and do not block. An empty or unknown selection is refused. Compile(model) is unchanged. See https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/interoperability.md (#656)
Screenplay (Release v4.134.0): The reference evaluator returns SemanticUnsupported when execution reaches a declaration a scoped plan did not admit. This covers a deferred command, query or projection, including projections that would observe published facts, so unadmitted semantics never run silently. (#656)
Stage (Release v4.69.0): Read-model browser at <stage base>/read-models, including behind Studio’s play-session proxy. Browse every modeled read model, including those without queries or instances, inspect keys and values, and refresh the current state. (#228)
Stage (Release v4.69.0): Semantic-engine endpoints GET /stage/read-models for property contracts and live instance counts, and GET /stage/read-models/{id} for instance keys and values. These diagnostic endpoints expose the whole session independently of query authorization; keep the session private behind a trusted proxy. (#228)
Stage (Release v4.69.0): Explicit unavailable states: loading returns HTTP 503; faulted sessions return HTTP 503 with state: "faulted" and no rows; refused models return the same HTTP 501 refusal as specification runs. (#228)
Stage (Release v4.69.0): Under the eventmodel engine, both endpoints return HTTP 404 JSON directing you to the Chronicle Workbench, and the browser displays that guidance instead of rows. (#228)
cli (Release v3.49.0): cratis render --scope <Module[.Feature][.Slice]> renders only the selected modules, features or slices; the option can be repeated. A renderer refusal (STAGE-ESM-*) in an unselected slice no longer blocks the render, while execution-plan errors (PLAN-*) anywhere in the model still do until Cratis/Screenplay#656 is available (part of #247)
cli (Release v3.49.0): Scoped renders never delete or overwrite files that belong to other scopes. The ownership manifest records which module, feature and slice each file comes from, and a later full render takes over every file a scoped render produced (part of #247)
cli (Release v3.49.0): A scoped render is refused before anything is written when a selected slice depends on declarations that are neither selected nor already in the destination (CLI-RENDER-014 names them and the scope to add), or when the destination still uses the aggregate policy layout, which needs one full render first (part of #247)
cli (Release v3.49.0): A scoped render into an empty destination includes the application scaffold so the result builds, and the receipt lists the scope, the slices outside it and any orphaned files; --check works with --scope (part of #247)
Chronicle (Release v19.46.0): ReactorScenario throws ReadModelNotSeededForReactorScenario when a handler takes a read model that was never seeded. Before, the handler silently ran with null. The message names the read model and the key it looked for, and lists the keys you did seed, so a mistyped key is obvious. Call Given.ForEventSourceId(id).NoReadModel<TReadModel>() when a handler should deliberately see no instance. Production behaviour is unchanged: a running reactor still receives null for an absent read model (#3912)
AI (Release v7.28.0): The Stage rendering skill teaches case tables (one generated specification class per case, named <Spec>_<Case>, from Stage 4.59.0; a name collision is refused with STAGE-CRATIS-004) and whole numbers rendered as long from ESM v8 (Stage 4.61.0; below v8 an out-of-int literal is refused with STAGE-ESM-031), and states that the CLI 3.46.1 default renderer (Stage 4.52.0) applies neither, with one evaluation per rule (#591)
AI (Release v7.28.0): The model-authoring and model-review skills teach semantic-diffbefore/after sources from Screenplay 4.131.0: the active workspace, a model folder or registered worktree, or an export, so a model is compared with main through a worktree path instead of two exports, and when to use read-proposal with view: "semantic-diff" instead (#592)
AI (Release v7.28.0): The cratis-arc-command and cratis-specifications-csharp skills teach Arc generated values: [GeneratedValue] on Handle() parameters for server-owned identifiers, when not to generate, analyzers ARC0022–ARC0025, and pinning generated values in CommandScenario specs with PinGeneratedValue, AllowGeneration and GeneratedValues (part of #576)
Stage (Release v4.68.0): CratisPlanOptions.Profile lets PlanFrom and PlanScaffold use the caller’s own render profile, with its authored documentation, strings catalog and scaffold inputs. A plan for a module, feature or slice is then byte-identical to the same files in a full render through that profile, and a scaffold-only render plus scoped renders with the same profile assemble into the same application. Scene composition is still produced only by application-scope plans; PlanScaffold reports STAGE-PLAN-031 when a profile carries one. Without a profile, output is unchanged. (#321)
cli (Release v3.48.0): A guarded screen action the Stage runtime can evaluate, such as Close shown only while item.status == "open", is rendered with its guard and its hidden fallback instead of being removed. Only a guarded action the runtime cannot evaluate is left out, and it is reported as a STAGE-SCENE-ACTION-001 warning. (part of #284)
cli (Release v3.48.0): The rendered application’s menu and breadcrumb follow the authored navigation hierarchy, and cratis run starts cratis/stage:4.67.0 by default. (part of #284)
Chronicle (Release v19.45.0): The PDL compiler adds a “did you mean” hint to a read model or property it cannot find, naming the registered read model whose title, short type name or casing matches, or the property whose casing differs (#4729)
Chronicle (Release v19.45.0): The reducer analyzer reports public reducer-like methods that will never be dispatched, for example Reduce(TReadModel? current, object @event), through the existing CHR0006 and CHR0007 diagnostics. It recognizes the same method shapes as the runtime, including previous event generations marked [EventTypeGenerationFor<T>] (#4726)
Stage (Release v4.67.0): A feature’s contribute to Navigation entries carry the module and features they were declared in, and the Stage menu renders them as a nested tree: groups for the module and each feature, entries ordered by their order, each linking to the screen it opens with the current screen marked. The breadcrumb shows the groups leading to the current screen. A feature’s entry arrives on each of its screens and is shown once. See Authored navigation hierarchy. (part of #237)
Chronicle (Release v19.44.0): ReactorScenario can seed events on a route: Given.ForEventSource(id).OnStream(eventSourceType, eventStreamType, eventStreamId).Events(...). The reactor sees the route in EventContext.EventSourceType, EventStreamType and EventStreamId. Every argument is optional and defaults to what appending to the event log uses. The same OnStream is available on reactors registered fluently (#4760)
Chronicle (Release v19.44.0): A new ProducedEvents list on ReactorScenario records every event a reactor produces together with its destination (event source id, event source type, event stream type and event stream id), resolved the same way a running reactor appends it. Assert it with ShouldHaveProduced<TEvent>(eventSourceId) or ShouldHaveProduced<TEvent>((produced, @event) => ...). See Asserting produced destinations
Stage (Release v4.66.0): Reducers in models with named event sources and streams can now be rendered with a from filter. The generated Chronicle reducer only sees events routed to that event source, or to that event source and stream, so unrouted events and events on other streams no longer change the read model. Plans for a module, feature or slice include the event source definitions a filter refers to. Reactions with a from filter are still refused with STAGE-ESM-035, and the Stage Host and specification runs still refuse reducers. (part of #297) (part of #207)
AI (Release v7.27.3): The corpus verification job replays the screens authoring workflow on the pinned public vector: it installs the pinned cratis CLI, materializes the published Cratis.Screenplay.CanonicalCorpus folder source (the corpus stays Screenplay-owned and is not copied), replays the stdio MCP transcript with the revision-checked column edit, renders the edited folder and requires the column in the generated scene.json. It runs locally with screens-smoke.sh <work-folder>; the pins live in screens-smoke.json. The browser step still needs Docker and Chromium and stays a documented manual step. (part of #536)
Scene (Release v4.19.0): PropertyDescriptor.open and CollectionItemDescriptor.open mark an Object property or the items of a Collection as open: fields the descriptor does not describe are kept exactly as stored and never edited, instead of being refused. Described fields are still checked. See Descriptors. (part of #70)
AI (Release v7.27.2): The authoring workflow now previews an edited model’s render with cratis render --check (CLI 3.44.0: exit 0 current, 6 changes pending, 5 refused) and reads the receipt’s sources and bySource (CLI 3.45.0) and MCP semantic-diff (Screenplay 4.131.0) to confirm an edit changed only what it should. They are labeled published, not executed on the verified vector. (part of #536)
AI (Release v7.27.2): The UI composition contract explains what Scene 4.17 does with an authored destination: nested core:outlet composition with deep links and innermost back, toolbar buttons that open a dialog or slice screen, the SettingsPage template and the embedded WebViewPackageHost. (part of #536)
AI (Release v7.27.2): Routing evaluations cover a build, edit and run request for a whole business application. (part of #536)
Scene (Release v4.18.1): Every business template preview in both blueprints is audited with axe-core’s WCAG 2.0 and 2.1 A and AA rules, in the populated, empty, loading and error states for the default blueprint. A control spec proves the audit reports a violation when there is one. Colour contrast and landmark rules need a real layout and are documented as not asserted. See The template set. (part of #73)
Stage (Release v4.65.0): Guarded actions run in the Stage frontend runtime: the action executes the first alternative whose guard holds for the item its screen’s single-item data declaration reads, with its with values taken from that item. When none holds, otherwise hidden renders nothing and otherwise execute <Command> offers that command. Without an item nothing is offered, and the action follows the data as it changes. (part of #236)
Stage (Release v4.65.0): Guarded on click, on double click and on select interactions run exactly the branch that holds for the row they happened on, or their otherwise actions, through the Scene interaction engine. A table that declares a double click no longer selects or navigates on the click that starts it. (part of #237)
cli (Release v3.47.0): cratis render renders Screenplay ESM v8 models: event sources, streams, routed commands and routed specifications render through the bundled Stage 4.62.0. ESM v9 and v10 are still refused with CLI-RENDER-004, naming the version (#290)
Scene (Release v4.18.0): PropertyDescriptor.properties describes the fields of an Object property. A field’s path is a single name relative to the object and a field may itself be an Object or a Collection, so a structured value of any depth is describable. See Descriptors. (part of #70)
Arc (Release v22.68.0): ARC0022 (error): a [GeneratedValue] parameter’s type cannot generate itself, or is nullable. (part of #3128)
Arc (Release v22.68.0): ARC0023 (error): [GeneratedValue] is used outside a command’s Handle method, for example on Provide, a static method, a read-model method or a controller action. (part of #3128)
Arc (Release v22.68.0): ARC0024 (error): two generated values on the same Handle have the same name. (part of #3128)
Arc (Release v22.68.0): ARC0025 (warning): the command’s Provide method also supplies the generated value’s type, which is never used for that parameter. (part of #3128)
Arc (Release v22.68.0): A documentation page for each of these analyzer rules. (part of #3128)
Chronicle (Release v19.43.0): ReadModelScenario can seed events on a route: Given.ForEventSource(id).OnStream(eventSourceType, eventStreamType, eventStreamId).Events(...). The projection or reducer sees the route in EventContext.EventSourceType, EventStreamType and EventStreamId. Every argument is optional and defaults to what appending to the event log uses (#4738)
Screenplay (Release v4.132.0): SemanticReactionSettlement lets a host that runs a model live settle event-triggered reactions after a command, with the same semantics as specifications: facts in append order, reactions in semantic-id order, from and where checks, productions before invocations, the declared runs as identity and the fact limit. The result is all-or-nothing. On acceptance it returns the settled world and only the facts the reactions appended, for the host to persist together with the command’s facts. On a rejection, conflict or unsupported capability it returns the input world. Invoked commands run through the evaluator the host passes in, so host checks also apply to them. See https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/reactions.md (#644)
Chronicle (Release v19.42.0): ReadModelScenario and ReactorScenario honour artifacts registered through ChronicleOptions.ExplicitArtifacts. Pass the options to the new Defaults(clientArtifactsProvider, serviceProvider, options) constructor, and specify a reactor registered with RegisterReactor through the new ReactorScenario(reactorId, defaults). (#4736)
Chronicle (Release v19.42.0): InMemoryClientArtifactsProvider lets a specification state exactly which artifact types a scenario sees. (#4736)
Chronicle (Release v19.42.0): Analyzer CHR0057 warns when a class implements more than one IProjectionFor<> or more than one IReducerFor<>. (#4734)
Arc (Release v22.67.0): CommandScenario<TCommand>.PinGeneratedValue(name, value) pins a generated value by its parameter name, and PinGeneratedValue<TCommand, TOtherCommand>(name, value) pins one for a command that runs inside the scenario’s command. Pins are fixed once the first command starts executing. (part of #3128)
Arc (Release v22.67.0): Generated values are strict by default in a scenario: a command whose generated value is not pinned fails with a message that names the command, the parameter and how to fix it. AllowGeneration() lets the scenario generate real values instead. (part of #3128)
Arc (Release v22.67.0): CommandScenario<TCommand>.GeneratedValues.Last<T>(name) and .All<T>(name) return the values a scenario generated or pinned. (part of #3128)
Arc (Release v22.67.0): Documentation on testing generated values, and an upgrade guide for moving from New() inside Handle and from the removed IIdentitySource and CommandScenario.Generate(...) to [GeneratedValue] and PinGeneratedValue. (part of #3128)
Chronicle (Release v19.41.0): .NET reactors and reducers can opt in to receive every event in the generation they handle, on live delivery, catch-up, replay and partition retries alike. Set ChronicleOptions.EventGenerationDelivery to EventGenerationDelivery.Pinned; the kernel then selects, decrypts and, when needed, migrates the event to that generation. Without the option, delivery is unchanged. See event type migrations (part of #4710)
Chronicle (Release v19.41.0): The event context carries AppendedGeneration, the generation the event was originally appended in (part of #4710)
Arc (Release v22.66.0): [GeneratedValue] and [GeneratedValue("name")] on a model-bound command’s Handle parameter: Arc creates the value with the type’s IGeneratable<T>.New() (for example a UUID-backed concept), validates it with the concept’s validator, and passes it to the handler. It never becomes a request property, so clients cannot choose it. A value the concept’s validator rejects is a server error, not a validation response. (part of #3128)
Arc (Release v22.66.0): CommandContext.GeneratedValues lists the values generated for the command, in resolution order. Generated values are never written to logs or exception messages. (part of #3128)
Arc (Release v22.66.0): A source generator registers an AOT-safe factory for each generatable type used in a [GeneratedValue] parameter. Without one, Arc falls back to reflection, and an AOT application refuses to start with an error that names the command and parameter. (part of #3128)
Arc (Release v22.66.0): A documentation page on generated values in commands: when to use them, how they are created and validated, and the pitfalls. (part of #3128)
Chronicle (Release v19.40.0): EventScenario constructors that take an explicit event sequence, event store and namespace, and still discover the constraints your application declares: new EventScenario(sequenceId, eventStore, @namespace) and new EventScenario(defaults, sequenceId, eventStore, @namespace). Passing an explicit null constraint provider to the existing constructor still means no constraints (#4520)
Chronicle (Release v19.40.0): ReadModelScenario, ReactorScenario and EventStoreForTesting implement IDisposable, like EventScenario. Dispose a scenario to release its in-memory event store, for example from your specification’s Destroy()
Stage (Release v4.61.0): STAGE-ESM-031 refuses a whole-number literal outside the int range in a model before ESM v8, naming v8 as the fix instead of failing as a C# compile error in the rendered application. Moving an existing model from v7 to v8 widens its stored event schemas, which Chronicle treats as a new event generation. (#263)
Screenplay (Release v4.131.0): semantic-diff compares the open workspace, a model folder or worktree, or an export: pass before and after as { "workspace": "active" }, { "path": "<folder>" } or { "workspaceJson": "<export>" }. A folder is read without writing anything, uses its persisted identities when it has them, and a folder with a pending interrupted write is refused (#558)
Stage (Release v4.60.0): Specifications that Stage renders for commands in models with named event sources and streams now check routes.
Stage (Release v4.60.0): Givens are seeded on their event source and stream.
Stage (Release v4.60.0): Each expected event’s event source type, stream type and stream id is asserted, or its absence when the specification says unrouted.
Stage (Release v4.60.0): Expected events in any order are matched one to one, as in Screenplay’s reference runner, so an event can’t satisfy two expectations.
cli (Release v3.46.0): cratis ai install and cratis ai update print a note when the cratis/codescene profile is selected: the CLI does not register the CodeScene MCP server, so register cs-mcp in your own user-level MCP configuration (#312)
Stage (Release v4.59.0): Specification case tables (Screenplay decision 0046) render as one specification class per case, named from the derived <Specification>_<Case> specification. Two case names that normalize to the same generated file are refused with STAGE-CRATIS-004 instead of overwriting each other. (#256)
Stage (Release v4.59.0): A failing case in a Stage specification run names its case and its effective fixtures, in the same Case '<Case>' of '<Specification>': … Effective fixtures: … form as Screenplay’s reference runner, in both the SpecRunner report and the Host’s run results. (#256)
Stage (Release v4.59.0): SpecificationExpansion.ExpandAll returns every effective specification of an authored specification, including each case of a table. LoadedSemanticModel.SpecificationOrigins and SemanticSpecificationRunOptions.SpecificationOrigins carry the compiler’s case provenance into a specification run. (#256)
cli (Release v3.45.0): cratis render and cratis render --check receipts list, for every path, the semantic declarations the file realizes (sources: id, kind and a readable Module/Feature/Slice/Name address), plus a bySource view that maps each declaration to its files; scaffold files have no sources. The receipt schema version is now 2 (#246)
cli (Release v3.44.0): cratis render --check plans exactly like a normal render. It then reports, per path, what a real render would write, delete, leave unchanged or refuse, and why. It writes nothing to the destination and does not recover an interrupted publication. It exits 0 when the destination is current, the new 6 (changes_pending) when a render would write, delete or rewrite the ownership manifest, and 5 when planning fails, the render would be refused or recovery is pending, so a CI step can gate on stale generated code (#245)
Chronicle (Release v19.39.2): A Help menu in the Workbench top bar with links to the Chronicle documentation and the Cratis Discord (#4722)
Templates (Release v1.7.4): Projects created from the Cratis templates say where to ask questions: the “project is ready” message and the generated README point to the documentation and the Cratis Discord (#75)
Stage (Release v4.58.0): Stage now renders Screenplay models that declare named event sources and streams and route commands to them.
Stage (Release v4.58.0): Each event source becomes a Chronicle IEventSource definition under EventSources/.
Stage (Release v4.58.0): Routed commands carry [EventSource<T>("<stream>")] and set the stream id on the events they append. The stream id can be a UUID, a text, a whole-number or a composite value, or a literal. Authorization and validation run before the route.
Stage (Release v4.58.0): A text stream id that cannot be used is returned as a validation error rather than an exception.
Stage (Release v4.58.0): Plans for a module, feature or slice include the event source definitions their commands use.
AI (Release v7.27.0): cratis/codescene profile, not part of cratis or cratis/full. It provides the CodeScene MCP server (cs-mcp), four CodeScene skills (safeguarding-ai-generated-code, guiding-refactoring-with-code-health, prioritizing-technical-debt, risk-based-testing-with-code-health) and a Code Health policy rule (#584)
AI (Release v7.27.0): The skills are taken from codescene-oss/codescene-mcp-server under Apache-2.0. Apart from licence metadata and modification notices, the only changes are an opt-in guard and a pointer to the Cratis policy. Each skill applies only in repositories that select the profile and have the CodeScene MCP tools available
AI (Release v7.27.0): The Code Health policy judges the change, not the file:
AI (Release v7.27.0): changed files must not decline in Code Health, and new files must score at least 9.0
AI (Release v7.27.0): files that already score low are improved only through dedicated, tested work
AI (Release v7.27.0): generated code is excluded, and Cratis conventions take precedence over findings
AI (Release v7.27.0): state-changing CodeScene tools need the user’s approval
Ante (Release v1.3.0): The loading screen shown before the application mounts is written by the server: Ante:PageTitle sets the tab title from the first paint, Ante:LogoUrl and Ante:CustomCssUrl apply immediately, Ante:SplashMessage sets the announced name, and Ante:SplashHtml replaces the screen with the host’s own markup. The default screen follows the --ante-splash-* custom properties.
cli (Release v3.43.2): cratis --help ends with where to ask questions: the Cratis Discord (part of Cratis/.github#48)
cli (Release v3.43.2): cratis chronicle diagnose points to the Cratis Discord when it finds problems, and the error report command mentions Discord for questions alongside the GitHub issue flow (part of Cratis/.github#48)
cli (Release v3.43.2): A “Questions and help” link to the Cratis Discord when opening a new issue (part of Cratis/.github#48)
Scene (Release v4.17.0): A core:outlet component declares a named nested outlet on a screen. A destination into it opens its screen there and keeps the declaring screen on the page, and the opened screen may declare outlets of its own, so composition nests to any depth. A deep link to the innermost level composes every level above it, and back closes the innermost level. See Navigation diagnostics. (part of #74)
Scene (Release v4.17.0): SceneNavigationContextValue exposes primaryScreen and outlets, which say which screen fills the primary region and each nested outlet. (part of #74)
Scene (Release v4.17.0): A SettingsPage screen template in @cratis/scene.blueprint.components: a module’s settings as a generated command form with save and discard. (part of #73)
Scene (Release v4.17.0): A descriptor for the Cratis Components toolbar button, so designers configure its label, icon, text, presentation and destination. (part of #74)
Scene (Release v4.17.0): A runnable embedded webview example renders a custom package set with WebViewPackageHost and forwards cratis.scene.* events to VS Code’s acquireVsCodeApi or the parent frame. See Package hosting. (part of #75)
Scene (Release v4.16.0): useValueOutput and valueOutputProperty in @cratis/scene.react publish and declare an input’s value output: on mount with the initial value and on every change, as JSON (dates as ISO 8601 strings). (part of #69)
Scene (Release v4.16.0): The PrimeReact text, textarea, password, number, date, dropdown, multi-select, radio, checkbox and toggle inputs publish and declare their value output, so a designer can offer it as a binding source. (part of #69)
Scene (Release v4.16.0): resolveArgumentSource (@cratis/scene.engine) and ArgumentSources.Resolve (Cratis.Scene.Engine) resolve a command argument source: component.<id>.<output> reads another element’s output, choosing the longest element id since ids may contain dots, and any other source is a data-context path. (part of #69)
Scene (Release v4.16.0): @cratis/scene.components/runtime exports cratisComponentsRuntimePackage with the components, descriptors and manifest, and loads no designer, property editor or design-time action. cratisComponentsDesignTime holds the design-time contributions. (part of #70)
Scene (Release v4.16.0): createHashSceneHistory keeps navigation entries in the URL fragment, such as index.html#/WorkItemDetails?workItemId=B, for hosts served as a single file or from a path they do not control. It also follows a fragment changed by hand. See Navigation diagnostics. (part of #74)
AI (Release v7.26.0): The Screenplay toolchain skill ships the machine-readable Screenplay contract for its pinned release, so agents can look up whether a diagnostic code, MCP tool or CLI option exists. (#552)
AI (Release v7.26.0): Corpus verification checks the Screenplay skills against that contract and fails on unknown or retired PLAY codes (including codes inside ranges), MCP tools and parameters, CLI commands and options, and stated tool counts, with the file and line of each finding. It also fails when the contract version differs from the pinned Screenplay version, and prints a coverage report of contract features no skill mentions. (#552) (#529)
AI (Release v7.26.0): Each Screenplay release, and a weekly run, checks the skills against the newest contract and opens, updates or closes one screenplay-sync tracking issue with the findings. (#529)
AI (Release v7.25.0): Corpus verification compiles every screenplay example in the skills with the pinned standalone Screenplay tool. Complete models must compile with no diagnostics, examples that demonstrate a diagnostic must produce exactly the declared codes, models with specifications run screenplay test, and fragments compile inside a declared parent or are listed as skipped. A skill opts in with a play-compiles assertion in its verification.json. (#416)
AI (Release v7.25.0): CI installs the Screenplay version pinned in the toolchain skill and requires the check; locally a missing tool is reported as skipped, never as passed, and a different tool version fails. (#416)
Chronicle (Release v19.39.0): IEventSequence.CompleteStream(ClosedStreamScope) closes a scope made of any non-empty combination of event source id, event source type, event stream type and event stream id; an append covered by a closed scope is refused with StreamClosed. A new EmptyScope error, and the same or an already covered scope returns AlreadyCompleted. See Scoped closing. (#4668)
Chronicle (Release v19.39.0): An optional expectedTailSequenceNumber on the scoped CompleteStream closes only when nothing was appended to the scope after your last fact, so an ad-hoc close cannot race a late append. (part of #4669)
Chronicle (Release v19.39.0): [ClosesStream] on an event type and IConstraintBuilder.ClosesStreamOn<TEvent>() declare a closing event: appending it closes the declared scope in the same append, later covered events (also later in the same AppendMany) are refused, ReopenedBy event types reopen the scope, and EventStreamIdFrom takes the stream id from an event property. Closures from closing events are rebuilt by constraint reindexing. See Closing events. (#4671)
Chronicle (Release v19.39.0): IEventSequence.IsStreamCompleted(ClosedStreamScope) and GetClosedStreams() tell whether a scope is closed and list closures; the Workbench lists the closed streams of an event sequence; the kernel’s ReopenStreamScope command repairs a mistaken manual close and records the reason and actor as a StreamScopeReopened system event. See Inspecting and repairing closed streams. (#4670)
Chronicle (Release v19.39.0): A “close the books” recipe shows how a closing or carry-over fact ends one period’s stream and the application starts the next. See Close the books. (#1448)
Chronicle (Release v19.39.0): Event seeding can target an event source type, event stream type and event stream id through new ForEventSource, For<TEvent> and ForEvents overloads; routing takes part in seeding idempotency, and existing seed data is not seeded again. (#4642)
Chronicle (Release v19.39.0): GetMetadataAt on the event sequence reads the metadata of events by exact sequence number (up to 500 per call) without reading or decrypting payloads, and resolves the caused-by identity, including its on-behalf-of chain, from the identity store at read time with an explicit resolution status for missing, unnamed and system identities. (#4683)
cli (Release v3.43.0): cratis chronicle auth status shows the server your login belongs to and whether the selected server matches it, with tokenServer and loginMatchesServer in JSON output (#198)
cli (Release v3.43.0): Commands print a notice when your stored login belongs to another server, so you know they are running without it, instead of reporting this only with --debug (#198)
AI (Release v7.24.0): Specification description, persona callers (given caller as <Persona>) and specification case tables, with their diagnostics. (#556)
AI (Release v7.24.0): Fenced Markdown documentation on modules, features, slices, commands, events, read models and reactions as the home for durable reasoning, with the MCP summary fields and diagnostics. (#538)
AI (Release v7.24.0): Whole-document authoring with propose-source, and the released MCP tool count. (#537)
AI (Release v7.24.0): The find-specification-obligations and find-modeling-smells review tools in scenario coverage and model review. (#541)
AI (Release v7.24.0): Routes in when redelivered locators, whole-route overrides and route origins in fixtures. (#550)
AI (Release v7.24.0): Guarded when/otherwise alternatives on on click, on double click and on select, the where deprecation on item triggers, and their diagnostics. (#551)
Chronicle (Release v19.38.2): Chronicle records which version of an event type’s migration definitions produced each generation added by the backfill, and keeps every version of those definitions instead of replacing them (part of #4189)
Stage (Release v4.57.0): CratisRendering.CheckPublication(plan, readExistingFile) tells a publisher whether it is safe to write a module, feature or slice plan into an existing application. It returns CratisPublicationCheck.Compatible, or CratisPublicationCheck.RequiresApplicationScope with the affected paths and a reason when the destination still has the policy layout from before Stage 4.50.0. An application-scope plan is always compatible. The check only reads the shared policy files the plan would overwrite, recognizes the current layout from their content, and treats unrecognized content as requiring application scope. The reader returns null only for a confirmed-absent file and must throw on a read failure. (#291)
Stage (Release v4.57.0): ArtifactRenderPlan.Scope records the scope a plan was planned for.
Screenplay (Release v4.129.0): Read-model properties take a trailing key modifier. Several properties marked key form a composite key. Queries name every key part in a by block, and command and trigger reads map each part by name (part = source) under by. A lookup that misses a part, names an unknown part or supplies an incompatible, optional, collection or literal value is reported (PLAY0660, PLAY0661, PLAY0662) (#459)
Screenplay (Release v4.129.0): A partial command reads … by can be completed by a typed repair when each missing part has exactly one same-named, compatible command property. Queries and trigger reads are not repaired (#459)
Screenplay (Release v4.129.0): A plain or inline produces can carry its own stream Source.Stream line with streamId mappings. It replaces the command route for that production only, and other productions keep the command route. A route line under a reaction or refusal production is an error (PLAY0663), and an override equal to the command route is a warning with a removal repair (PLAY0664) (part of #302)
Screenplay (Release v4.129.0): Reactions and reducers take from Source or from Source.Stream and then see only facts routed there. Unrouted facts never match. An invalid filter is an error (PLAY0665), and a filter that excludes every known producer of a trigger event is a warning (PLAY0666) (part of #302)
Screenplay (Release v4.129.0): ESM v10 admits production route overrides and observer filters next to the reaction system identity. A model selects v10 when it uses any of the three. Every other model keeps its version and bytes, and strict readers for schema 9 and earlier reject the new members (part of #302)
Screenplay (Release v4.129.0): Monaco and the VS Code extension highlight, complete and explain keys, by blocks, production routes and filters. The event model board shows key fields, composite lookups, per-production routes and what each reaction or reducer observes
Screenplay (Release v4.129.0): The Invoicing sample routes payments through a Payment event source with a production override, filtered reactions and reducers, and a composite-keyed view. The TimeTracking sample reads an engagement month row by its composite key
AI (Release v7.23.0): The $identity caller root, and the identity block that describes identity details as authoring metadata, with diagnostics PLAY0633 to PLAY0646. (#571) (#572)
AI (Release v7.23.0): The personal-data and secret markers, their qualifiers and scopes, purpose declarations with their checks and the processing report, as released in Screenplay 4.127.0. (#548)
AI (Release v7.23.0): PLAY0653 for a repeated compliance marker, and that pii personal is one marker. (#577)
AI (Release v7.23.0): The event data-subject mark with diagnostics PLAY0590 to PLAY0595, and that it is reported, not yet acted on. (#554)
AI (Release v7.23.0): Reaction runs as system diagnostics PLAY0647 to PLAY0652, the trusted-actor privilege check, and the corrected premise about Arc’s system identity. (#574)
AI (Release v7.23.0): Composite and personal or secret stream ids (PLAY0515), PLAY0504 as an error for mismatched routed destinations, stream-id literal checks and canonical comparison. (#539) (#545)
AI (Release v7.23.0): Self-describing identity-migration refusals (identityMigrationIssues) and PLAY0345 to PLAY0348 in the editors. (#540)
cli (Release v3.42.0): cratis screenplay conform <MODEL_ROOT> checks that hand-written code still matches an authored Screenplay model: it extracts a model from the code with the same source adapters as cratis screenplay generate, without writing anything, and compares it with the model using Screenplay’s own comparison (#259)
cli (Release v3.42.0): Code elements missing from the model and event or member shape mismatches are reported as blocking drift; model elements not yet realized in code are reported as informational, since a model may legitimately be ahead of the code (#259)
cli (Release v3.42.0): conform exits 0 when the code conforms, 1 on blocking drift and 2 when the check could not run or could not compare everything, and -o json gives machine-readable findings for CI (#259)
Stage (Release v4.56.0): Exposures (exposure for) and instance values (instance) are carried on the Scene application as ExposureDeclaration/ExposedProperty and InstanceContribution/ContributedItem, including collection operations, editable fields, re-exposures and item values. (part of #236) (part of #237)
Stage (Release v4.56.0): A contribute to block written inside a screen now contributes its directives to the named contribution point, after what the screen’s module and feature contribute. (part of #236) (part of #237)
Stage (Release v4.56.0): Screen and dialog templates carry their slot content, display name, description and picker scopes; scopes none stays distinct from no scopes. (part of #236) (part of #237)
Stage (Release v4.56.0): Arrangements carry grid columns and rows, fractional grow and span on containers as well as slots. (part of #236) (part of #237)
Stage (Release v4.56.0): A navigate directive’s route, outlet and parameters become a typed Scene DestinationReference on the element’s destination property. (part of #236) (part of #237)
AI (Release v7.22.0): Model authoring teaches the MCP dependency graph and board dependency map, named-rule and handler intent views, specification route rows, the evidence-pinned repair loop (including the PLAY0516 timeline repair), semantic diff, completeness checks, scoped diagnostics and worktree-aware state roots. (#532)
AI (Release v7.22.0): The language skills teach depends on, exact numbers, event-source and stream routes in commands and specifications, systems and operations, typed specification examples, reaction refusals and redelivery, runs as system role on reactions, policy negation and guarded screen actions. (#532)
AI (Release v7.22.0): The toolchain skill lists PLAY0514 to PLAY0517 and the completeness diagnostics, explains --scope and --check, and says which verdicts editors show and which need the screenplay tool or the MCP diagnostics tool. (#532)
AI (Release v7.22.0): Legacy extraction covers --authoring-only-constructs and what the Arc generator now recovers, including SP0039 for scenarios whose event sources cannot be stated. (#528)
Arc (Release v22.65.0): The Screenplay generator writes event sources, streams, command routes and specification routes into its default output wherever Screenplay’s executable model (ESM v8) can state them. This covers property, literal and single-placeholder [EventStreamId("{Name}")] stream ids, and no stream on unrouted expected events. (#3090)
Arc (Release v22.65.0): Routes Screenplay still refuses are left out with a diagnostic naming why, and stay available behind ScreenplayOptions.AuthoringOnlyConstructs. That covers property-path and handler-command mappings, generated-property mappings, colliding source or stream names, and a source named Default. (#3090)
Stage (Release v4.55.0): Screenplay specifications for models with named event sources and streams now run in the Stage Host and with --engine semantic. Givens and appended events are written with their event source type, stream type and stream id. Expected events are compared by route, including unrouted. Expectations in any order are matched one to one, so an earlier match can no longer consume the event a later expectation needs. The run report shows each event’s route. Structural SpecRunner runs keep refusing routes with STAGE-ESM-030. (part of #177)
Screenplay (Release v4.127.0): ModelComparison.Compare in Cratis.Screenplay.Comparison compares two Screenplay models and returns a typed structural difference: declarations added, removed, renamed or moved, changed members, event contract changes and generation coverage, specification expectation changes, direct dependants, identity changes, and what was not compared (#555)
Screenplay (Release v4.127.0): Models without persisted identities, such as one freshly generated from code, are compared by matching declarations on kind and address; renames and moves then show as a removal and an addition rather than being guessed (#555)
AI (Release v7.21.0): The cratis-fundamentals-concept skill teaches concepts that create their own value: implement IGeneratable<TSelf> and generate with GenerateValue.Uuid(), or GenerateValue.UuidV7() when index locality matters, from Cratis.Fundamentals 7.23.0. It covers the v7 trade-offs (reveals creation time, not monotonic within a millisecond) and when not to generate: client-supplied ids, secrets and tokens, and idempotency. (part of #576)
AI (Release v7.21.0): Evaluations for cratis-fundamentals-concept: a self-generating identity, choosing UUID v7, and refusing generation where it does not fit. (part of #576)
Screenplay (Release v4.126.0): A concept that repeats a compliance marker, such as pii personal, pii pii or secret secret, now gets warning PLAY0653. Both compilers keep the first marker, attach the concept’s pii and secret settings to it and print it once. A quick fix in the editors and the MCP propose-repair tool removes the repeat (#584)
Stage (Release v4.54.0): The Stage Host now runs Screenplay models that declare named event sources and streams and route commands to them. Each appended event carries its event source type, stream type and stream id. The Host registers the model’s event sources with Chronicle each time it connects. Routed events are read back with their route when the Host rebuilds its state after a restart. A route the model could not have produced is refused, not ignored. (part of #177)
Screenplay (Release v4.125.0): ESM v10 (language and semantic 10.0, schemaVersion: 10) admits the reaction system identity as the SemanticReaction member runsAs ({"kind":"system","roles":[...]}, roles sorted). Only models that declare runs as select it; every other model keeps its version and bytes, and strict readers for schema 9 and earlier reject the member (#383)
Screenplay (Release v4.125.0): Specifications run a reaction’s invoked and returned commands as an authenticated system identity holding exactly the declared roles, so a role-gated invocation succeeds with runs as and is refused without it. Claim conditions against this identity are unknown and deny, and a specification’s given caller is never passed to invocations
Fundamentals (Release v7.23.0): IGeneratable<TSelf> in Cratis.Concepts: a concept implements static TSelf New(), so constrained generic code can create it without reflection and with Native AOT (part of #1176)
Fundamentals (Release v7.23.0): GenerateValue.Uuid() returns an RFC 9562 version 4 UUID from RandomNumberGenerator (part of #1176)
Fundamentals (Release v7.23.0): GenerateValue.UuidV7() returns an RFC 9562 version 7 UUID: Guid.CreateVersion7() on .NET 9 and later, and an equivalent implementation on .NET 8 (part of #1176)
Scene (Release v4.15.0): Cratis.Scene.Engine.Bindings: BindingResolver, BindingValidation, BindingScope and QueryBindingState resolve data context, query, component output and literal bindings with the same null behavior, diagnostics and cycle detection as the TypeScript engine. See Binding resolution. (part of #69)
Scene (Release v4.15.0): nestBindingScope, removeComponentOutputs and QueryBindingState in @cratis/scene.engine give nested templates their own data context, drop the outputs of elements that leave the tree, and accept a bound query’s result only for its latest run. (part of #69)
Scene (Release v4.15.0): useBoundQuery in @cratis/scene.react reruns a bound query when its arguments change, aborts the previous run, ignores its late answer and clears the result when the selection is cleared or the rebind fails. (part of #69)
Scene (Release v4.15.0): stackCommandFormLayout and the command form’s widthSizeClass property: at Compact a manual form stacks its fields in one column in reading order. See Command form geometry. (part of #71)
Scene (Release v4.15.0): applyCommandFormLayoutKey and the commandFormLayout property editor move a form field with the arrow keys and resize it with Shift and an arrow key, announcing moves that would leave the declared columns. (part of #71)
Scene (Release v4.15.0): resolvePackageHost resolves the UI profile’s layout and theme from the approved packages as host.layout and host.theme. See Package hosting. (part of #75)
Scene (Release v4.15.0): isNetworkAsset decides which package assets reach beyond the host. (part of #75)
Screenplay (Release v4.124.0): A reaction can declare the system identity its invoked commands run under: runs as system, optionally followed by role "<Role>" repeated with and. It prints after the description and before the first trigger and round-trips in both compilers, editors and MCP declaration-details. Until the identity is admitted into the executable model, binding a reaction that declares it reports PLAY0268; models without it are unchanged (part of #383)
Screenplay (Release v4.124.0): New diagnostics: PLAY0647 for a malformed, repeated or misplaced runs as or empty or duplicate roles, and warnings for a reaction invoking a gated command without an identity (PLAY0648), an identity on a reaction that neither invokes a command nor has an implementation body (PLAY0649), a declared role no invoked command needs (PLAY0650) and an identity that definitely cannot satisfy an invoked command’s gate (PLAY0651) (part of #383)
Screenplay (Release v4.124.0): An opt-in privilege completeness check (PLAY0652) reports each producer of a reaction’s trigger event that can cause an elevated reaction without holding the reaction’s roles itself (part of #383)
cli (Release v3.41.0): cratis render resolves every ui profile against the packages the bundled cratis target renders (core, scene.web and Cratis.Components) before it publishes anything. A profile it cannot honor stops the render: nothing is published, and managed artifacts from an earlier render stay as they were. The new diagnostics are CLI-RENDER-007 (unknown package), CLI-RENDER-008 (missing layout), CLI-RENDER-009 (packages that cannot be combined, such as an incompatible theme or a missing dependency) and CLI-RENDER-010 (undeclared theme). See UI profile resolution. (part of #284)
Stage (Release v4.52.0): cratis render emits the Stage frontend runtime into a generated application under .frontend/stage, with src/stage-scene.json (the composed Scene with native command form metadata) and src/stage.ts (routes read from the generated Arc proxies, plus localized strings). The generated frontend renders the full composed application instead of a single screen. (part of #236)
Stage (Release v4.52.0): CommandFormSchemas in Cratis.Stage.Contracts gives the presentation schema and form fields for a command’s properties, so the same command shows the same form fields in a live Stage and in a generated application. (part of #236)
Stage (Release v4.52.0): The Stage frontend reads its Scene, routes and strings through a StageSource, which serves either the /stage endpoints or content built into an application. App also accepts extra components for its registry. (part of #237)
Stage (Release v4.52.0): Verification/generated-react-browser runs the browser scenarios used against a live Stage against a generated application served on its own backend: two-item scoped selection, deep link, delayed-response discard, clear, native create, rename and add-comment forms, theme, and fail-closed guarded actions. (part of #237)
Chronicle (Release v19.38.0): Unique constraints can now keep every value an event source appends instead of one value per event source. Set Mode = UniqueConstraintMode.PerValue on [Unique], or call WithMode(UniqueConstraintMode.PerValue) on the unique constraint builder. A value then stays reserved until a removal event releases it. A removal event can name the properties that carry the value to release ([RemoveConstraint(..., Properties = [...])], RemovedWith<TEvent>(e => e.Id)); without properties it releases every value the event source holds. The existing behaviour stays the default (#4641)
Screenplay (Release v4.122.0): A top-level identity block declares typed identity details beyond the token built-ins, each from exactly one source: from claim "<name>", from query <Name> by <expression>, or an inline code or file implementation. It is authoring metadata, like authentication: it parses, validates, prints, merges across a folder and is navigable in the editors and MCP, but adds nothing to the executable model. Reading a declared detail with $identity.<detail> where it would execute reports PLAY0268 until the block is admitted (#119)
Screenplay (Release v4.122.0): New diagnostics PLAY0633–PLAY0646 for invalid or duplicate identity blocks and details, missing or unknown sources, bodies under a sourced detail, redeclared built-ins, and query sources that are not keyed single results, use other details in by, return a mismatched type or are guarded by authorization that depends on identity details
Screenplay (Release v4.121.0): $identity.<property> reads the caller wherever an expression is accepted, as a shorter root for $context.identity.<property>. It names the same properties (id, name, userName, isAuthenticated, roles, claims.<name>), warns with PLAY0155 on an unknown property, and compiles to exactly the same executable model as the $context.identity spelling. $context.identity keeps working unchanged. Both editors highlight, complete and check the new root (part of #119)
Arc (Release v22.64.0): IIdentitySource gives commands, queries and Arc’s own event source id allocation a single, replaceable source of new identities; a handler takes it as a Handle() parameter (#3070)
Arc (Release v22.64.0): CommandScenario and QueryScenario gain Generate(...), which queues the identities a spec expects so generated ids can be asserted exactly (#3070)
Screenplay (Release v4.120.0): exposure for <Owner> declares what a layout, screen template or dialog template lets an instance configure: component properties by identifier or exact quoted stable id, with an optional label, collection operations (add, remove, reorder, edit-fields), editable item fields and reexposes <Owner>. Maps to Scene’s ExposureDeclaration and ExposedProperty. (part of #168) (part of #173)
Screenplay (Release v4.120.0): instance <Screen or Template> stores typed literal values (set <component>.<path> = <value>) and collection items (items / item <id>) for what was exposed. Maps to Scene’s InstanceContribution and ContributedItem. (part of #168) (part of #173)
Screenplay (Release v4.120.0): contribute to <Point> [order <n>] inside a screen contributes content to a contribution point, mapping to Scene’s Screen.Contributions. (part of #168) (part of #173)
Screenplay (Release v4.120.0): Screen and dialog templates can provide their own slot content with content <slot>, and picker metadata with display, description and scopes (application, module, feature, subfeature, slice or none); layouts accept scopes. (part of #168) (part of #173)
Screenplay (Release v4.120.0): Flow arrangements accept grid ... columns <n> rows <n>, grow [<number>] and span <n> on containers, and a weighted grow <number> on slots. Navigation accepts outlet <name>. (part of #168) (part of #173)
Screenplay (Release v4.120.0): New diagnostics PLAY0621–PLAY0632 reject malformed composition, unknown exposure owners and instances, unexposed or mistyped instance values, re-exposure cycles and broken re-exposures, unknown template content slots, unknown navigation outlets, template scope mismatches and components from packages no ui profile declares. The source stays in the syntax tree. See diagnostics. (part of #168)
Screenplay (Release v4.120.0): The canonical screen composition corpus covers every new construct in its typed positive vector and adds six rejection vectors with exact diagnostics and no artifacts. (part of #168)
Scene (Release v4.14.0): SceneNavigationHost records every navigation as a history entry. With createBrowserSceneHistory(window, basePath), route overrides and their parameters reach the address bar, deep links open the matching screen with its parameters, a refresh restores the entry, and the browser’s back and forward buttons step through screens. createMemorySceneHistory gives embedded hosts the same behavior. See Navigation diagnostics. (part of #74)
Scene (Release v4.14.0): Dialog destinations open as their own history entry. closeDialog(result) returns to the screen that opened the dialog and exposes the result as dialogResult, and the browser’s back button also closes the dialog. (part of #74)
Scene (Release v4.14.0): matchSceneRoute and sceneRoutesFrom match a URL to a screen route, capturing {name} path segments and query parameters; a URL that matches nothing is reported as unresolvedUrl. (part of #74)
Scene (Release v4.14.0): A MasterDetail screen template in @cratis/scene.blueprint.default: a list beside the selected record, with a detail outlet that accepts Detail screens, stacking at a compact width. (part of #73)
Scene (Release v4.14.0): GalleryScreenPreview takes a state (populated, empty, loading or error), applied by applyTemplatePreviewState to data-bearing elements only, so a template can be previewed in each data state. (part of #73)
Scene (Release v4.14.0): The PrimeReact dataTable accepts loading and error: it announces a loading status or an error alert in place of its rows and keeps its column headers. (part of #73)
Scene (Release v4.14.0): A pattern-to-template coverage matrix compares the MUI Store, Creative Tim, React Themes and ThemeForest business patterns with the templates that implement each, with priorities and deferred patterns: Business pattern coverage. (part of #73)
Arc (Release v22.63.0): [EventStreamId("{ReportingScopeId}:{Period}")] builds a command’s stream id from its own properties, so owner-qualified ids no longer need ICanProvideEventStreamId. Concepts contribute their underlying value, dates and times use fixed invariant formats, and the id is resolved after validation, so a validator can reject a missing part. EventStreamIdTemplate.ResolveFor(command) returns the same id for reads and seeding. See Concurrency. (#3102)
Arc (Release v22.63.0): EventRoute carries the source type, stream type and stream id of a route. Resolve it from an event source definition with IEventRoutes.For<TSource>(stream), read the command’s own route with CommandContext.GetEventRoute(), and stamp returned events with route.Route(id, events), so command metadata, reads and appends use one value. (part of #2987)
Arc (Release v22.63.0): IStreamReads reads one stream, or every stream of one stream type, for an event source, tail first. The returned StreamDecision.Append(...) appends routed events guarded at that tail. An empty stream is checked as a first append, and a concurrent append into the same stream comes back as a concurrency validation failure. See Stream decisions. (#3101)
Arc (Release v22.63.0): Return CompleteStream from a command handler, alone or next to its events, to close a stream after the command’s events commit. Reactors can return it too. An already completed stream counts as success, and a later append to the closed stream is a validation failure. Closing happens after the commit, not atomically with it. See Completing streams. (#3091)
Arc (Release v22.63.0): Commands can tag the events they append with structured named tags: [EventTag("projectId", nameof(ProjectId))], ICanProvideEventTags, a returned EventTags value, or application-wide ICanProvideCommandEventTags providers. Tags on returned EventForEventSourceId wrappers are kept on every append path. See Event tags. (#2570)
Arc (Release v22.63.0): CommandScenario can seed events on a route (Given.ForEventSource(id).OnRoute(route).Events(...)), append competing events on a route (AppendConcurrently(id, route, events)), and assert closed streams with ShouldHaveCompletedStream(...).
Arc (Release v22.63.0): Analyzer ARCCHR0016 warns when a command declares concurrency: true but Handle returns EventsWithConcurrencyScopes, whose exact scopes replace the attribute’s. A code fix removes the flag. (#3100)
Arc (Release v22.63.0): Analyzer ARCCHR0017 reports an [EventStreamId] template that names a missing, non
AI (Release v7.19.0): LanguageModelResult.IsQuotaExhausted, PoolAttemptOutcome.QuotaExhausted, and TriedProviders and QuotaExhaustedProviders on PoolDispatchResult (#423)
AI (Release v7.19.0): The worker failed callback carries reason: "quotaExhausted" with provider, plus model and vendorCode when known, when the agent session ran out of quota. Other failures send the same fields as before (#423)
Arc (Release v22.62.0): [EventTag("name", nameof(Property))] on a command tags every event it appends with a property value, or with a constant through Value (#2570)
Arc (Release v22.62.0): ICanProvideEventTags on a command, and application-wide ICanProvideCommandEventTags services resolved per command from its scope, supply tags computed at runtime (#2570)
Arc (Release v22.62.0): Returning an EventTags value from Handle() adds tags known only once the handler has run (#2570)
Scene (Release v4.13.0): diagnoseNavigation (@cratis/scene.engine) and NavigationDiagnostics.Diagnose (Cratis.Scene.Engine) report duplicate routes, duplicate, missing and incompatible outlets, navigation cycles through nested outlets and unavailable screen or dialog targets, with the same codes and messages in both engines. diagnoseRenderedNavigation in @cratis/scene.react compares the routes the renderer actually builds. See Navigation diagnostics. (part of #74)
Scene (Release v4.13.0): An outlet can list the template types it accepts; a destination placing any other screen there is diagnosed as an incompatible outlet. (part of #74)
Scene (Release v4.13.0): TemplateMetadata carries compatibility (Scene and package version ranges), attribution and an SPDX license with licenseUrl, in both the TypeScript and C# models. validateTemplateMetadata / TemplateMetadataValidation.Validate reject missing or invalid values, and describeTemplateCatalog / TemplateCatalog.Describe list every template with whether it can be used and why not. See Template compatibility, attribution and license. (part of #73)
Scene (Release v4.13.0): resolvePackageHost exposes the approved bundles’ template catalog as templates; set sceneVersion on the host configuration to check each template’s Scene range. (part of #73)
Scene (Release v4.13.0): resolveDesignTimeHost loads package previews, designers, property editors, property displays and design-time actions through generic lookups, with a generic fallback and a diagnostic for every unknown, undeclared, unloaded or incompatible extension. PackageDesignTimeMetadata.contractVersion and DesignTimeContractVersion version the contract. See Package design-time extensions. (part of #70)
Scene (Release v4.13.0): runDesignTimeAction submits an action’s canonical edit batch whole or not at all, so host validation and undo stay authoritative. (part of #70)
Stage (Release v4.51.0): CratisRendering.PlanFrom(PlaySources, PlanSelection, CratisPlanOptions) compiles .play files and folders and plans the selected modules, features, sub-features and slices, named by their authored path. Several entries combine into one plan. Files that are not selected are still compiled, so concepts, application-level declarations and sibling features can be passed in as context without being rendered. The result is a CratisPlanResult with the artifacts, typed diagnostics and a digest. An overload accepts an already loaded model.
Stage (Release v4.51.0): CratisRendering.PlanScaffold(CratisPlanOptions) plans only the application scaffold, at the application root, without any Screenplay sources. Plans for a module, feature or slice never contain the scaffold.
Stage (Release v4.51.0): The Domain option on CratisPlanOptions places slice code under {Domain}/{Module}/{Feature}/… and concepts and types under {Domain}/Common, with namespaces that follow the folders. Without a domain, the output is unchanged.
Stage (Release v4.51.0): ArtifactRenderPlan now carries a digest of the planned output. The same sources and selection produce the same artifacts and digest, whatever order the files are listed or found in.
Stage (Release v4.51.0): Typed STAGE-PLAN-* diagnostics report unknown modules, features or slices (listing the names that exist), an empty selection, an invalid or reserved domain, sources outside the root and sources that do not compile. A source plan never comes back silently empty. Symbolic links and other reparse points below the source root are refused rather than followed. See https://github.com/Cratis/Stage/blob/main/Documentation/reference/plan-from-sources.md. (#210)
Screenplay (Release v4.119.0): Added a render audit to the screens acceptance harnesses. It renders the canonical screens vector with the installed CLI and checks that two renders are byte-identical and that no artifact contains a timestamp, a GUID absent from the source, an absolute path, or host and user details. It also checks that a changed UI profile and a modified managed artifact are refused, and that the rendered application can be recovered into the same commands, events, read models and queries. run-public-acceptance.sh runs it after its self-test. (part of #168) (part of #173)
AI (Release v7.18.0): A bundle-diff run mode for the agent harness images (DIRECT_RUN_MODE=bundle-diff). The worker fetches a git bundle of the baseline commit from DIRECT_BUNDLE_URL, never clones or pushes, and refuses to start when repository credentials or clone inputs are present. It posts { diff, sha256, structured: { outcome, touchedFiles, gaps, summary, selfChecks }, usage, correlation } to DIRECT_RESULT_URL before the completion callback. The outcome is Completed, NoChanges, Refused or Cancelled (#566)
AI (Release v7.18.0): Phase progress events (started, cloned, agentRunning, diffReady) posted to DIRECT_PROGRESS_URL by every harness, carrying the caller’s DIRECT_CORRELATION fields verbatim (#566)
AI (Release v7.18.0): On SIGTERM, a bundle-diff worker posts its partial diff marked Cancelled within the termination grace period (#566)
AI (Release v7.18.0): WorkerRuntimeOptions.WorkerDeadline and an optional WorkerJob.Deadline set the Kubernetes Job’s ActiveDeadlineSeconds, which was fixed at 48 hours (the default is unchanged) (#566)
AI (Release v7.18.0): WorkerLaunchOutcome.ConfigurationTooLarge: the Kubernetes runtime refuses a job whose mounted files would overflow the 1 MiB Secret limit, before creating anything, and logs the total and the largest files (#566)
Chronicle.Mcp (Release v2.0.0): A Mutation deployment profile (Cratis__Chronicle__Mcp__Profile=Mutation). It enables the job-control tools only for a configured principal, with an expiry date and grants scoped by event store, namespace, operation and job. (#21)
Chronicle.Mcp (Release v2.0.0): Denied tool calls return a stable, machine-readable error ({"error":{"code":"…","operation":"…"}}) with the codes not_authenticated, not_authorized, principal_revoked, policy_expired, policy_invalid, bad_request and chronicle_denied. The error never includes store, namespace, target or credential details.
Chronicle.Mcp (Release v2.0.0): Grants and revocations are checked again on every call, so revoking a principal or letting the policy expire takes effect without a restart.
Chronicle.Mcp (Release v2.0.0): Chronicle MCP releases are listed in the official MCP Registry as io.github.Cratis/chronicle-mcp, using the versioned Docker image. The listing starts the server in the read-only profile. (part of #5)
Stage (Release v4.50.1): The Stage event model carries each read model’s modeled queries (Queries, with name, by parameter and cardinality), and /stage/routes resolves a by query by its modeled name. See Query endpoints. (part of #236) (part of #237)
Screenplay (Release v4.118.0): Added a screens release acceptance matrix to the Screenplay documentation. It maps each criterion of the screens-release issues to merged source, released versions and executed proof, and lists the browser runtime blockers that remain open. See Screens release acceptance. (part of #168) (part of #173)
Screenplay (Release v4.118.0): Added run-public-acceptance.sh, which runs the browser, MCP transcript and Studio acceptance harnesses with one command against the installed CLI and the Stage image that CLI defaults to. It fails when the CLI or Stage version differs from the expected one. (part of #173)
Stage (Release v4.50.0): Scoped render plans now include every concept and composite type their selected slices reference, transitively, including through projections over other modules’ events and through scoped projection children, joins and removals. The rendered files are byte-identical to the ones an application-scope plan produces. Concepts and types that the selection does not reference are left out.
Screenplay (Release v4.117.0): ESM v9 admits public event, event X from "store", direction inbound|outbound on Translate slices, projections and reducers that target a slice’s public event, and source events captures; models using them bind and run instead of being refused with PLAY0268. Public and foreign imports stay refused. (part of #480) (part of #481) (part of #482) (part of #483) (part of #484)
Screenplay (Release v4.117.0): The reference evaluator publishes the slice’s public event from private events, one instance per event source id, so specifications can say when append <private event> then <PublicEvent>.
Screenplay (Release v4.117.0): Canonical serialization and the full-esm-v9.json golden carry event visibility and origin, slice direction, event targets and the events source of a capture, with PublicEventsCorpus.V9 as the source-backed vector.
Screenplay (Release v4.117.0): Samples: Invoicing gains an outbound translation and Commerce an inbound one.
AI (Release v7.17.0): Screenplay MCP verification now includes a real stdio JSON-RPC transcript harness for scratch-corpus proposal, revision, stale-apply, and comment-preservation checks. (part of #536)
AI (Release v7.16.0): Claude subscription conversations through the official Claude Code CLI, with streaming responses, native caller functions, structured output, and usage reporting. Requires Claude Code on the service PATH and Unix owner-only temporary files. See subscription transport.
AI (Release v7.16.0): Default Claude Code model aliases for subscription providers without a model catalog: Fast uses Haiku, Balanced uses Sonnet, and Powerful/Premier use Opus. Explicit model mappings and discovered catalogs take precedence.
Screenplay (Release v4.114.0): Shared Screenplay syntax, AST, printer and transport support for typed component literals, literal bindings and exact component stable ids, with matching TypeScript parser/model coverage. (part of #168) (part of #173)
Screenplay (Release v4.114.0): Scene 4.12 command-form geometry authoring with generation, layout, columns, placements, gaps and width units preserved through the shared Screenplay ABI. (part of #168) (part of #173)
Screenplay (Release v4.114.0): Rich screen corpus coverage for typed literals, exact stable ids, form geometry, package component bindings, templates, outlets and multiple screens. (part of #168) (part of #173)
Chronicle (Release v19.37.0): Events source type, with Sequence and Events on the capture source definition. (part of #4640)
Screenplay (Release v4.112.0): public event declarations, and an opaque quoted store origin on events and imports (event X from "store", import Qualified.X from "store"). Events stay private unless declared public. (part of #481)
Screenplay (Release v4.112.0): direction inbound or direction outbound on Translate slices; a Translate slice without a direction stays inbound. (part of #480)
Screenplay (Release v4.112.0): Outbound translations can produce their public event with a projection or reducer whose => target is the event. (part of #482)
Screenplay (Release v4.112.0): source events captures with from <Event> lines, which turn another application’s public events into private events in an inbound translation. (part of #483)
Screenplay (Release v4.112.0): Diagnostics PLAY0607 to PLAY0620 that keep public and private events apart, and a repair for PLAY0614 that declares the one consistent direction. (part of #484)
Screenplay (Release v4.112.0): Support for the new forms in the TypeScript compiler, the Monaco language service, the VS Code extension, the event model board, the MCP tools and the published contract.
Screenplay (Release v4.110.0): Screen composition corpus now includes a browser-native controls harness that starts the released Stage runtime, drives Chromium, and records the exact missing Stage endpoints blocking full browser assertions. (part of #168) (part of #173)
Chronicle (Release v19.36.0): [Public] attribute marks an event type as public so it can be published outside the event log. (part of #4634)
Chronicle (Release v19.36.0): [PublishTo] attribute and event sequence targets let a projection or reducer append its output as events to a named event sequence. (part of #4635)
Chronicle (Release v19.36.0): Event type visibility and origin are stored with registered event types in the in-memory, MongoDB and SQL providers. (part of #4636)
Chronicle (Release v19.36.0): Publications are recorded idempotently, and registering two publishers of the same event type to one sequence is rejected. (part of #4639)
Chronicle (Release v19.36.0): Documentation for public events and event sequence targets. (part of #927)
Screenplay (Release v4.109.0): Screen composition released-vector results now record the CLI 3.40.1 authored Scene render, including authored screens, templates, dialog, navigation, profile, command/query bindings, and remaining guarded-action warnings. (part of #168) (part of #173)
Screenplay (Release v4.108.0): Screen composition corpus now records exact released-vector results for CLI 3.40.0, Stage 4.49.1, bundled Screenplay 4.105.0, Scene 4.12.0, and Studio 0.136.3. (part of #168) (part of #173)
Screenplay (Release v4.108.0): Released-vector assertions now distinguish generated backend command/query forms from the authored full-app screens contract, including missing master/detail, navigation, dialog, profile, and package/icon surfaces. (part of #168) (part of #173)
AI (Release v7.15.0): Screenplay screen authoring guidance now covers component data-context bindings, exposed templates, manual form columns, packages/icons, hierarchical outlets, routes, toolbar dialogs, and support-level reporting. (part of #536)
AI (Release v7.15.0): MCP screen authoring workflow now connects revision-checked proposal/apply editing with same-source validation, render, and runtime parity checks. (part of #536)
Screenplay (Release v4.107.0): purpose <Name> declarations with basis (GDPR Art. 6(1)), interest, condition (Art. 9(2)), authorization (Art. 10), subjects, retention, recipient, transfer … safeguard and erasure exception (Art. 17(3)), referenced with purpose <Name> from modules, features and slices; they are report-only and do not change the executable model (part of #557)
Screenplay (Release v4.107.0): The opt-in check --check purposes asks about personal data with no purpose in scope, special-category data without an Art. 9(2) condition, criminal-offence data without an authorization, purposes without a lawful basis and purposes nothing references (part of #557)
Screenplay (Release v4.107.0): A record of processing activities generated from the model, through the MCP processing-record tool and screenplay report processing --format json|markdown|csv, with a DPIA prompt and a finding when erasing a data subject would also destroy data kept under a legal obligation; it is generated from declarations and is not legal advice (#557)
Screenplay (Release v4.107.0): description "…" on concepts, policies, constraints, projections, screens and forms (#535)
Screenplay (Release v4.107.0): The concepts guide explains each GDPR special category (pii special …) and criminal-offence data (pii criminal), with links to the regulation, and the editors show the same explanation on hover (part of #557)
Screenplay (Release v4.106.0): Screen composition corpus now records working-branch harnesses with exact Stage, Studio, Scene, and Screenplay branch heads, commands, statuses, and release-switch rules for full-app screens parity. (part of #168) (part of #173)
Screenplay (Release v4.106.0): Working-branch assertions now cover Stage screen planning, Studio Screenplay transport, Studio native Play metadata, Scene form geometry, browser native controls, and MCP revision-edit transcript expectations. (part of #168) (part of #173)
Scene (Release v4.12.0): Platform-neutral command form geometry metadata for columns, field placement, spans, gaps and typed width units, with JavaScript and .NET model parity. (part of #73) (part of #75)
Scene (Release v4.12.0): Command form layout validation, defaults, legacy width-token migration and resize/placement draft helpers that keep invalid draft geometry separate from committed metadata. (part of #74) (part of #75)
Scene (Release v4.12.0): Dirty command value preservation helper for metadata edits and query refreshes. (part of #75)
Scene (Release v4.12.0): Native command form rendering for typed geometry, including valid submit behavior and invalid geometry blocking before the native submit boundary. (part of #73) (part of #75)
Scene (Release v4.12.0): Command form geometry reference documentation for downstream Screenplay, Stage and Studio consumption. (part of #73) (part of #74) (part of #75)
Stage (Release v4.48.0): A complianceDetails render option renders Screenplay concept compliance metadata: personal data gets [ComplianceDetails] with its GDPR Art. 9(1) special category or Art. 10 criminal-offence prefix followed by the authored reason, and secrets get [Encrypted] with their encryption scope and reason. The option is off by default, so existing models render unchanged until it is settled whether a details change counts as an event schema change (https://github.com/Cratis/Chronicle/issues/4660). (#250)
Screenplay (Release v4.105.0): Executable semantic model support for observable collection queries without a key and observable collection queries keyed by one caller-supplied by argument, including canonical JSON for Stage consumers. (part of #536)
Screenplay (Release v4.105.0): Documentation and contract examples for Stage consumers showing unkeyed list query routes, keyed list query routes, and the unsupported filtered, scoped, performer-backed and source-filled variants. (part of #536)
Screenplay (Release v4.104.0): given caller as <Persona> runs a specification as an authenticated caller built from the persona’s policies. When a policy has alternatives, the leftmost one that can be built is used, and hover and MCP show which. The opt-in personas completeness check reports ambiguous personas, personas that gate nothing and gates no persona reaches (#382)
Screenplay (Release v4.104.0): A specification can run over named case blocks with typed parameter lines, reading values as case.<name>. Each case runs and reports as its own specification, <Specification>_<Case>, in both compilers, the editors, the board, MCP run-specifications and screenplay test --filter (#449)
Screenplay (Release v4.104.0): The machine-readable Screenplay contract lists persona callers, case tables and their diagnostics
Scene (Release v4.11.0): Executable business gallery grouping for scope-aware Scene templates, with recursive package-host rendering for Components blueprint gallery screens. (part of #73)
Scene (Release v4.11.0): Runtime package host surfaces for standalone, embedded and webview rendering, including approved asset and font emission through the real Scene React renderer. (part of #75)
Scene (Release v4.11.0): Blocking package-host behavior so profiles with dependency, policy, asset or design-time diagnostics expose no partial runtime registry or rejected assets. (part of #75)
Scene (Release v4.11.0): Runtime-only and design-time package separation so hosts can render safe runtime bundles without loading optional design-time contributions. (part of #75)
Scene (Release v4.11.0): Scene navigation host for hierarchical screen, outlet, deep-link and dialog composition through rendered Scene trees. (part of #74)
Screenplay (Release v4.103.0): MCP propose-move moves a slice to another feature, or a feature to another module or feature, as a reviewable proposal that keeps every semantic and event-contract identity, repairs references (including screen actions and depends on), and refuses moves that would change inherited authorization or interaction behaviour, collide with an existing name, or lose an identity (#386)
Screenplay (Release v4.103.0): screenplay contract writes a versioned, machine-readable contract of the language: keywords and constructs, every diagnostic with its severity and title, every MCP tool and CLI command with their parameters, and which constructs each executable model version admits. Every fact is derived from the compiler, and the contract ships as a release asset and inside the Cratis.Screenplay.Tool package (#500)
Screenplay (Release v4.102.0): Screen composition corpus now carries authored folder-source behavior assertions for master/detail selection, query rebinding, native form validation, dialog routing, package profile fallback counts, and browser control behavior. (part of #168) (part of #173)
Screenplay (Release v4.102.0): Folder-source MCP and harness expectations record the import/edit/export, browser, CLI/Stage, and Studio surfaces without marking unexecuted harnesses as passing. (part of #168) (part of #173)
Screenplay (Release v4.102.0): RegisterProject legacy corpus now includes a pinned Stage execution vector with the released render manifest, scene plan, typed bindings, and artifact hashes as a compatibility vector. (part of #173)
Arc (Release v22.61.0): The generator now uses Cratis.Screenplay and @cratis/screenplay-language 4.98.0, so the embedded viewer picks up the newer language (#3078)
Arc (Release v22.61.0): A concept marked both [Encrypted] and [NotAudited] is generated as @sensitive, and as @pii @sensitive when it is also [PII]. Markings on a property or its positional constructor parameter are read as well (#3079)
Arc (Release v22.61.0): A concept with only [Encrypted] or only [NotAudited] is not marked @sensitive; the partial marking is reported as SP0058 (Information) (#3079)
Arc (Release v22.61.0): With ScreenplayOptions.AuthoringOnlyConstructs enabled, specifications state where events land: stream <Source>.<Stream> and streamId on given and appended events, and no stream on expected events. Source and stream declarations are added for routes the specifications state (#3060)
Arc (Release v22.61.0): Expected events can carry the issued command’s route when every production uses command context and the stream id is a concrete value (#3060)
Screenplay (Release v4.101.0): ESM v8 makes event sources, streams and command routes executable. A model that declares a source, routes a command or states a specification route selects v8; every other model keeps its version and bytes.
Screenplay (Release v4.101.0): The model lists eventSources, a command carries a route, and every fact the command produces carries a route with its source kind, stream kind and encoded stream id. (part of #407)
Screenplay (Release v4.101.0): The stream id is resolved after validation and requirements, and before generated values are produced. If it can’t be formatted (empty text, non-NFC text, or an integer outside ±(2^53−1) in the default numeric mode), the command is rejected as Contract. Nothing is appended for it, and earlier facts in the same cascade are kept. (part of #407)
Screenplay (Release v4.101.0): given and when append events with a route are placed on that stream.
Screenplay (Release v4.101.0): then compares the route, and no stream requires an unrouted fact.
Screenplay (Release v4.101.0): A routed fixture or example is typed by its source’s identifier, even when no command produces the event.
Screenplay (Release v4.101.0): Composite stream ids run at v8. Parts are encoded in declaration order with the escaped | separator, and specifications compare them part by part. (part of #462)
Screenplay (Release v4.101.0): Route lines in typed specification examples now run as well. Redelivery locators keep their route lines refused until reaction redelivery is admitted. (part of #491)
Screenplay (Release v4.101.0): MCP propose-rename now moves a source’s identity entries together with its streams. Readiness reports routes as admitted, and the semantic diff marks a reordered, retyped or added stream id part as contract-breaking. (part of #407)
Screenplay (Release v4.100.0): pii special <category> marks GDPR Art. 9(1) special-category data (health, genetic, biometric, racial or ethnic origin, political opinions, religious or philosophical beliefs, trade union membership, sex life or sexual orientation), and pii criminal marks Art. 10 criminal-offence data (part of #557)
Screenplay (Release v4.100.0): secret scope subject|namespace|global states the Chronicle encryption scope for an operational secret (part of #557)
Stage (Release v4.46.0): Generated specification classes carry the Screenplay specification’s description as their escaped <summary>, on both render paths. Specifications without a description render as before. (#249)
Screenplay (Release v4.99.0): on click, on double click and on select interactions can choose a whole action list from the item’s state, with ordered when branches and an optional otherwise that use the guarded-action condition language. This works in screens, named behaviors and component outlets, in both compilers, the editors and the Invoicing sample (#447)
Screenplay (Release v4.99.0): Decision record 0048 specifies guarded interactions and how the old where guard migrates (#447)
Arc (Release v22.60.0): The embedded event model board shows each slice’s specifications as cards for the given events, the action, the expected events and the expected errors. Everything else a specification states, such as the caller, the clock, generated values, then returns responses, read models given or expected absent, query results, operations and stream routes, appears in the card header. (#3080)
Arc (Release v22.60.0): The generated Screenplay derives a screen’s title, table and column directives from DataPage, DataTableForQuery, DataTableForObservableQuery and Column imported from @cratis/components, and an action from CommandDialog. A table or action is written only when it names a query or command the slice declares. (part of #3049)
Stage (Release v4.45.0): Scoped projections can set literal values in every blocks at levels without a join. Stage writes each literal onto every from at that level, where Chronicle applies every-mappings. Levels that combine an every literal with a join, literals that overlap a parent or child path of a from mapping, and literals in all blocks stay refused with a typed reason. (part of #117)
Arc (Release v22.59.0): Generated queries carry the method’s XML summary as their description. (#3048)
Arc (Release v22.59.0): Query parameters with a default value are emitted as optional filters, and nullable returns, including through Task<T> and ValueTask<T>, are emitted as optional returns. Default values and nullable collection elements, which Screenplay cannot state, are reported as SP0019. (#3048)
Arc (Release v22.59.0): With ScreenplayOptions.AuthoringOnlyConstructs, a query with a body gets a performer naming the file that holds its read logic. By default the performer is left out and reported as SP0019, because performer-backed queries are not executable. (#3048)
Arc (Release v22.59.0): A query that receives Arc’s QueryContext is reported as SP0041: it is a host dependency, so no from $context source is inferred. (#3048)
Arc (Release v22.59.0): Policies written with RequireAssertion that compare a claim to a property of the command are emitted as claim conditions matching the artifact property, keeping &&, || and grouping. A comparison against the identifier becomes matches subject. (#3050)
Arc (Release v22.59.0): Policies on a keyed snapshot query that compare a claim to the key supplied by the caller are emitted as matches subject. (#3050)
Stage (Release v4.44.0): A Stage host running the semantic engine can run the model’s specifications on request with POST /stage/semantic/specifications/run, optionally limited to a list of semantic scopes. Each run uses fresh, isolated state in a separate SpecRunner process, which the Stage image now ships, so it never touches the live session’s world or event store. Specifications Stage cannot run exactly come back as typed Unsupported results with the capability and the reason, never as passes. (part of #23)
Screenplay (Release v4.98.0): A when redelivered <Event> to <Reaction> locator can now state the redelivered event’s route, with stream Source.Stream (plus a streamId or composite part block) or no stream. Two given events that differ only in their stream can then be told apart. A locator matches only when exactly one given event definitely fits. (part of #490)
Screenplay (Release v4.98.0): Typed event examples can now carry a route. A step that uses the example can replace that route as a whole, and the route’s origin (authored, example or override) appears in the effective specification API and in MCP find-fixtures. (part of #491)
Screenplay (Release v4.96.0): Positive typed screen source case for component bindings, master/detail templates, command forms, dialog outlets, navigation, package profiles, icons and presentation hints. (part of #168) (part of #173)
Screenplay (Release v4.96.0): Browser, MCP, CLI, Studio and Stage harness expectation contracts with machine-checkable assertions and explicit pending version vectors for final released-package parity. (part of #168) (part of #173)
Stage (Release v4.42.0): Rendered commands and read models carry their Screenplay documentation block as escaped <remarks> in the generated C#, like events already do. (#243)
Screenplay (Release v4.95.0): screenplay test [path] [--filter <address>] [--format text|json] runs a model’s specifications with the reference runner and reports each as passed, failed, unsupported or unbound, with expected and actual events, read-model state, command responses and query results for failures; it exits 1 when any specification fails and 3 when nothing failed but something could not run (#377)
Screenplay (Release v4.95.0): MCP run-specifications runs specifications selected by address, semantic id or scope, with the same outcomes and failure details, in revision-pinned pages (#377)
Screenplay (Release v4.94.0): Typed screen bindings for data context, query results and component outputs, including null behavior, update mode, expected value metadata and invalid raw-text preservation. (part of #536)
Screenplay (Release v4.94.0): Screen package component, toolbar, navigation route, form column, template metadata and profile icon authoring across the C# and TypeScript compilers, Monaco keywords, VS Code grammar, samples and documentation. (part of #536)
Screenplay (Release v4.94.0): MCP authoring coverage for creating the screen release fixture and editing typed component bindings and dialog/navigation actions with revision-checked proposals. (part of #537)
Stage (Release v4.41.0): Scoped projections that clear a nested object and later re-create it render again, now that the pinned Chronicle kernel stores this shape correctly. Composite-key lookups, FromAll, literals in every/all blocks and root join removals stay refused. (part of #117)
Scene (Release v4.10.0): Shared rendered binding scope for Scene React trees, with typed component-output property resolution, preserved cleared values and stale-query abort support. (part of #69)
Scene (Release v4.10.0): Generic design-time package context with canonical Scene state, diagnostics, permissions, capabilities and edit/action submission for package designers and property editors. (part of #70)
Scene (Release v4.10.0): Command form package-side designer and property editor registrations that execute through generic design-time boundaries and preserve the native command form runtime contract. (part of #71)
Scene (Release v4.10.0): Renderer-side destination resolution for stable navigation identity, bound deep-link parameters, outlets and dialog actions. (part of #74)
Scene (Release v4.10.0): Package host resolution diagnostics for duplicate bundles, dependency/version conflicts, forbidden design-time imports, network assets and duplicate runtime singletons, with resolved layout, template, theme, icon and asset outputs. (part of #75)
Scene (Release v4.10.0): Category and scope metadata on business list, live list, master/detail and command form blueprint templates for package-backed galleries. (part of #73)
Screenplay (Release v4.93.0): The compiler packages now include a shared stream id formatter: SemanticStreamIdFormatter in .NET and the exported stream id functions in TypeScript. It formats single-value ids and encodes and decodes composite ids, using the same rules in both languages. A shared set of vectors checks both. (part of #407)
Screenplay (Release v4.92.0): ScreenCompositionCorpus.V1 with single-file, folder, reordered and relocated source forms, screen behavior probes, and pinned backend ESM admission diagnostics for the screens-release authoring fixture. (part of #168) (part of #173)
Scene (Release v4.9.0): Typed binding contracts for data context, query result, component output and literal sources, with resolver diagnostics for cycles, missing components and type mismatches. (part of #69)
Scene (Release v4.9.0): React component output scope for element-to-element bindings, including lifecycle cleanup for cleared selections. (part of #69)
Scene (Release v4.9.0): Package design-time metadata and optional React design-time bundles for previews, designers, property editors, display renderers and canonical edit actions. (part of #70)
Scene (Release v4.9.0): Command form descriptors for auto/manual mode, responsive columns, field widths and deterministic field generation through the native Arc form runtime. (part of #71)
Scene (Release v4.9.0): Stable destination, outlet and navigation metadata for hierarchical screens, dialogs, authored routes and toolbar/navigation chrome. (part of #74)
Scene (Release v4.9.0): Frontend package host configuration for approved bundles, profile resolution, assets, design-time loading policy and duplicate runtime singleton diagnostics. (part of #75)
Scene (Release v4.9.0): Business blueprint pattern and package-hosting documentation for embedded and standalone rendering hosts. (part of #73)
Screenplay (Release v4.91.0): Specifications accept a description line that says which rule or behavior they witness (#392)
Screenplay (Release v4.91.0): Modules, features, slices, commands, read models and reactions accept a fenced Markdown documentation block, like events. It is report-only authoring metadata: it never changes the executable model, folder merge keeps the first file’s block and reports conflicting blocks, and the MCP declaration-details summary returns description and documentation for every declaration that has them (#392)
Screenplay (Release v4.91.0): New diagnostics PLAY0558 (malformed documentation block) and PLAY0559 (conflicting module or feature documentation across files) (#392)
Screenplay (Release v4.90.0): MCP semantic-diff compares two exported model revisions (export-workspace snapshots) with the same paged structural, identity and dependency output as a proposal’s semantic diff, and refuses unreadable, incompatible or stale revisions (#456)
Screenplay (Release v4.90.0): MCP find-specification-obligations lists, for every command, read model, policy and constraint in a module, feature or slice, the specifications its structure calls for (success, each rule and authorization denial, constraints, removals and more) and whether a matching specification exists (#390)
Screenplay (Release v4.90.0): MCP find-modeling-smells asks advisory questions about generic update or CRUD names, events that repeat another command’s event shape, and commands or read-model properties with many events; it never changes compilation results (part of #393)
cli (Release v3.37.0): cratis render writes authored Screenplay description text as XML doc comment summaries on generated commands, events, read models, queries and types, and event documentation as remarks. Metadata the renderer cannot use, such as text with characters invalid in XML, blocks rendering with CLI-RENDER-005. When the documents cannot be read as a Screenplay workspace, for example a file with an upper-case .PLAY extension, the model renders without the comments and CLI-RENDER-006 says why. (#278)
cli (Release v3.36.0): cratis screenplay validate <path> --scope <Module>[.<Feature>[.<Slice>]] checks one module, feature or slice and the declarations that directly reference it, with the same selection and exit-code rules as the screenplay tool; the whole application’s error and warning counts are always reported alongside, in the console and in JSON, and --scope combines with --check (#274)
Screenplay (Release v4.88.0): Event streams can declare a composite id: a streamId block with two or more named parts. Command routes and specification routes then map each part by name, as part = value. Both compilers parse, check and print these, and so do the typed syntax, MCP, the web editor, VS Code and the event model board. Single-value stream ids are unchanged. Composite routes are not executable yet, like every route today (PLAY0268). (#462)
Scene (Release v4.8.0): Component packages can declare a checked mapping from their independent Scene catalog to a Components renderer, with diagnostics for incompatible identity, ABI, profile, slots and capabilities. See manifest authority. (#27)
Scene (Release v4.8.0): Layouts, screen templates and dialog templates support optional semantic types, custom browse categories and scope restrictions, with shared C#/TypeScript validation for application hierarchy and recursive slot compatibility. Application shells remain layouts, and templates remain optional for outlet-only composition. (#72)
Stage (Release v4.38.0): A converted ReadModelDefinition names the projection its read model was built from (SelectedProjectionName) and lists the other projections the slice declares (IgnoredProjectionNames), so an importer can tell people which projection was used. Which projection is chosen is unchanged. (#218)
Stage (Release v4.37.0): Screenplay csharp and file policies render as Arc authorization when their body passes Stage’s pure-code checks. The body sees the caller (authentication, roles and claims, with roles kept separate from claims), the command identifier or query key, and the time Arc received the command or query as PolicyContext.Occurred. Opaque and portable policies compose in authored order, and an authorization that reaches an opaque policy without a receipt time or subject denies. Bodies that read the tenant, the untyped artifact or identity names are refused with STAGE-ESM-015. (part of #57)
Chronicle (Release v19.35.0): eventSequence.Prepare(event) serializes an event once with the store’s real event serializer, including polymorphic types and additional-information providers, and returns a PreparedEvent snapshot that append and verification both reuse. (#4510)
Chronicle (Release v19.35.0): AppendPrepared(eventSourceId, preparedEvent) appends a prepared event, and AppendPrepared<TEventSource>(...) does the same through a registered event source, resolving routing and concurrency scope the way Append<TEventSource> does. (#4510)
Chronicle (Release v19.35.0): eventSequence.VerifyContent(sequenceNumber, preparedEvent, eventSourceId) reports whether the complete content of a stored event is Equal, Different or Unavailable compared with the prepared event, without returning the stored content to the caller. Erased, unreadable and revised content is Unavailable, as is content on SQL storage, where revision state is not yet tracked. (#4510)
Chronicle (Release v19.35.0): Verification compares content across every stored generation of the event type and reports Unavailable when any generation cannot be compared without losing precision. (#4510)
Chronicle (Release v19.35.0): The Workbench exposes a VerifyContent command and generated proxies for content verification. (#4510)
Screenplay (Release v4.87.0): A public .NET API for scoped validation: ScopedDiagnostics.TryValidate in Cratis.Screenplay.Mcp takes a file or folder path (or the sources in memory), a module, feature or slice address and the completeness checks to run, and returns the scope’s diagnostics, its direct dependents, the affected scopes, unresolved event consumers and the whole application’s error and warning counts. An unknown or ambiguous scope and an unreadable path are reported as errors. The screenplay tool and the MCP diagnostics tool use the same implementation (#533)
Screenplay (Release v4.86.0): The propose-source MCP tool proposes whole .play documents as text (create, replace, remove, move and rename a document key), validated as authoring source with identity continuity and reviewed and applied like any other proposal. Text that does not parse returns SourceParseFailed with located diagnostics and no proposal (#385)
Screenplay (Release v4.85.0): Warning PLAY0557 when a reaction’s on refused by authorization branch invokes an authorization-gated command: reactions have no invoking identity yet, so the reference runner always refuses the command and the branch always fires, while Arc runs reactor commands as the system. Reported by both compilers, in the Monaco editor and in VS Code workspace files (#489)
Stage (Release v4.36.0): claim matches subject and claim comparisons with a property work against Date and DateTime values. The claim must equal the value’s canonical text exactly as Screenplay writes it (yyyy-MM-dd for a Date; the round-trip format with Z for UTC for a DateTime), independent of culture; any other spelling never matches. This applies to generated applications and to Stage’s own specification runner. (part of #57)
Screenplay (Release v4.84.0): The MCP propose-rename tool now renames event sources and event streams. Renaming a source updates the source in every command route and specification route that names it. Renaming a stream updates only the routes to that source’s stream. Existing id pins are kept exactly as written, and none are added. A rename is refused when the new name is already a source, when it is already a sibling stream, or when the source is declared in more than one place. (#467)
Screenplay (Release v4.83.0): The web editor and VS Code now complete depends on targets in module and feature bodies. They list the sibling features, the siblings of each enclosing feature, the root modules, and qualified paths to features in other modules, nearest first. After a typed module name and a dot, they list that module’s features. The container itself, its ancestors and descendants, and targets it already declares are left out. (#494)
cli (Release v3.35.0): cratis screenplay validate --check <names> runs Screenplay’s opt-in structural completeness checks (data-bindings, input-surfaces, field-origins, query-keys, event-consumers, navigation, the codes PLAY0530–PLAY0537, or all). The option can be repeated, its findings are warnings that fail only with --warnings-as-errors, and the checks are skipped with a note when the model has errors. It combines with --executable. (part of #274)
Stage (Release v4.35.0): Specifications can use Screenplay example declarations, including step overrides and inline assignments, on every Stage path: rendered specifications, the in-memory runner and the event-model runtime all see the same values as when they are written out. (part of #209)
Screenplay (Release v4.82.4): An editor diagnostic support reference lists the diagnostics the TypeScript compiler and the editors share, and the checks that still need the screenplay tool or the MCP diagnostics tool (part of #495)
Arc (Release v22.58.0): The Screenplay generator writes a reactor as a declarative reaction, with produces or invokes and mappings from the triggering event, when its handler unconditionally returns an event, a command, or a literal collection of either, and Chronicle runs it for every such event. Reactor scenarios of such reactors become when append specifications. Everything else keeps its file reference. (#3040)
cli (Release v3.34.0): cratis screenplay validate and the embedded MCP server accept policy negation (not role, not claim, not authenticated and not (...)), which selects ESM v7, and warn with PLAY0546 when not applies to a claim whose target can be absent or is not text. cratis render rejects such a model with the blocking CLI-RENDER-004 diagnostic, because the bundled renderer does not render it yet. (#271)
cli (Release v3.34.0): Screenplay models can declare depends on for modules and features, define reusable example values for specifications, give a screen action conditional alternatives, and route specification events with stream. cratis screenplay validate checks them; specification event routes and reaction on refused, when redelivered and then no events are not executable yet, so cratis screenplay validate --executable and cratis render report PLAY0268 for them.
cli (Release v3.34.0): The embedded MCP server’s diagnostics tool takes scope (one module, feature or slice) and checks (opt-in completeness checks); cratis screenplay validate does not offer these yet. The server also adds a semantic-diff view to read-proposal, a dependency map on the event model board, dependency declarations in dependency-graph and declaration-details, routing data and effective example values with their origin in find-fixtures, examples in search, references and rename, routing data in find-references and dependencies, and opens other registered Git worktrees of the same repository.
Stage (Release v4.33.0): Policies can use not, with Screenplay’s fail-closed meaning: a claim comparison that cannot be decided (a missing, null or non-text target) stays undecided under not, and an undecided policy denies. This applies to generated applications and to Stage’s own specification runner. (part of #209)
Stage (Release v4.32.0): Rendered C# carries Screenplay description as each declaration’s <summary> and event documentation Markdown as <remarks>, copied as escaped text, for commands, events, read models, queries and types. Declarations without a description keep their generated summary unchanged. (#178)
Stage (Release v4.32.0): CratisRendering.WithAuthoringMetadata(profile, compilation) adds a model’s descriptions and documentation to a render profile, so a render host that has the Screenplay compilation can include them when planning from the executable model. (#178)
cli (Release v3.33.0): cratis screenplay desktop install|status|update|uninstall manage the Screenplay MCP server in Claude Desktop and ChatGPT Desktop as regular subcommands, with their own help, shell completion and llm-context entries. --model-root is offered only by install and update. (#240)
Screenplay (Release v4.81.0): Policy conditions accept not <condition>, including not role "…", not claim … matches … and grouped conditions; not binds tighter than and, which binds tighter than or. A claim comparison whose target is missing, null, an absent subject or not text is unknown, not keeps it unknown, and a policy whose result is unknown denies access. Warning PLAY0546 flags not over a claim whose target can be absent or is not text. Negating a policy reference or an opaque predicate is refused. (#431)
Screenplay (Release v4.81.0): Models that use not select ESM v7, which gains a not policy condition in this release; models without it keep their version, bytes and revision. Consumers that read v7 must admit the new condition kind, and older strict v7 readers reject it. (#431)
Screenplay (Release v4.81.0): Declare example <Name> : <Event|Command|ReadModel> once and use its name wherever that type goes in given, given readmodel, when, when append, then and then readmodel, overriding values with the step’s indented lines or one inline assignment such as given AcmeInvoice total = 5000. Examples expand before binding, so the executable model is the same as writing the values out; a property missing from both the example and the step is reported at the step. Examples cannot state event source or stream lines; state those on the step. (#427)
Screenplay (Release v4.81.0): MCP find-fixtures shows effective fixture values with their origin (authored, example or override), examples appear in search, references and dependencies and can be renamed safely, and .NET embedders get expanded specifications with the same origins. Monaco and the VS Code extension complete examples and show effective values on hover; the Invoicing, Commerce and TimeTracking samples use them. (#427)
Screenplay (Release v4.81.0): A screen can offer one action that runs one of several commands depending on the selected item: action "<label>" with ordered when <condition> execute <Command> alternatives and an optional otherwise hidden or otherwise execute <Command>. The first alternative whose condition holds decides, a condition on a missing or null field does not match, and when none holds the fallback runs or the action is hidden, as it is when no item is selected. Running the selection needs renderer support. (#432)
Screenplay (Release v4.81.0): A reaction’s invokes can declare what happens when the command is refused, with ordered on refused branches (optionally by validation, by constraint [Name] or by authorization) that acknowledge the refusal or produce events using $refusal.reason, $refusal.constraint and $refusal.message; specifications can use `when redelivered to
Screenplay.CritterStack (Release v0.26.0): Generated models link commands to the events their handlers append through Marten Events.Append and StartStream, and through Wolverine aggregate handlers (#80)
Screenplay.CritterStack (Release v0.26.0): Public diagnostic codes WolverineDiagnosticCodes.ProductionLinkOmitted and CritterStackDiagnosticCodes.MixedSliceKindsSplit identify omitted production links and split feature slices
Chronicle (Release v19.34.0): Publish open alert incident gauges by event store, namespace, observer, event sequence, condition and severity, with periodic sampling, stale-snapshot suppression and owner failover. (#4533)
Stage (Release v4.27.0): Policies that check only a role or only a claim render as Arc policies. Signed-in callers with the role or claim are allowed; everyone else, including callers who are not signed in, is denied. Roles are read through the identity’s role claim type. (part of #57)
Stage (Release v4.27.0): claim matches subject works against Uuid subjects. The claim must equal the Uuid’s canonical text exactly (lower-case, hyphenated), as in Screenplay’s reference semantics, in generated applications and in Stage’s own specification runner; a missing claim or any other spelling denies. (part of #57)
Stage (Release v4.26.0): Reducer bodies can read context.Tenant and compare it with TenantId.Default and TenantId.NotSet. (#185)
Stage (Release v4.26.0): When a code body uses the authored camelCase name of a generated member, the compile error now names the generated PascalCase member and points at the .play or attachment line and column. (#185)
Screenplay.CritterStack (Release v0.25.0): Authored enums are declared as Screenplay enumeration concepts (#76)
Screenplay.CritterStack (Release v0.25.0): Wolverine SlicePattern handlers and Marten FetchManyForWriting streams are recognized
Chronicle.TypeScript (Release v6.51.0): Transactional appends retain routing, subject, occurrence time, tags and concurrency scopes through commit in enrollment order, and reject conflicting scopes for one event source before enrollment. (#204)
Arc (Release v22.57.0): Generated Screenplay specifications state then returns when an Arc command scenario asserts the command’s response against a literal, for scalar responses and for asserted fields of record responses. Commands without generated values keep their returns beside successful scenarios. Generated values still cannot be pinned from Arc specs, so commands with them keep their previous form. (part of #2887)
Arc (Release v22.56.0): ScreenplayOptions.MaximumExecutableModelVersion (MSBuild CratisEmbeddedScreenplayMaximumExecutableModelVersion, for example 6.0) keeps generated Screenplay documents below a given executable model version. Below 7.0, generated identifiers, generated values and command responses are left out with SP0052, so tools that do not admit ESM v7 yet, such as cratis render, accept the document. (#3056)
Arc (Release v22.55.0): The Screenplay generator binds every document it generates, not only compiles it. Binding errors that are not known limits of the executable model are reported as SP0056: a warning when you generate yourself, information inside an application’s build so it never fails the build. Embedded generation binds the document that holds the whole application. (#3039)
Arc (Release v22.54.0): Generated Screenplay documents declare each read model as a readmodel, with its properties, its XML summary as description, and its source file. Projections and keyed queries therefore resolve the read model they name. Each read model is placed once per document, in the slice that owns it. Scoped embedded documents import it from the document that declares it. A read model that cannot be declared faithfully is left out and reported with SP0057. (#3047)
Screenplay (Release v4.80.0): MCP find-fixtures lists the event source and stream, stream id or no stream stated on specification events. find-references and dependencies on an event source or stream now include the specifications that route events to it. (part of #457)
Screenplay (Release v4.80.0): The web editor completes stream, streamId and no stream under specification events and their stream targets, shows hover help, and lists PLAY0547–PLAY0551. VS Code highlights the route lines and lists the same findings. (part of #457)
Screenplay (Release v4.80.0): The event model board shows the routes a specification states in its header. (part of #457)
cli (Release v3.32.0): cratis screenplay validate --executable also binds the model into an executable semantic model and fails with its binding diagnostics, such as PLAY0268 for event sources and streams, when it does not bind. It never renders, writes files or needs a container runtime, and its JSON summary reports executable. A document a root file imports from above its folder reports CLI-VALIDATE-001, and a document the binder cannot represent reports CLI-VALIDATE-002. (#243)
Screenplay (Release v4.79.0): Modules and features that state depends on are now checked against the dependencies Screenplay infers from their slices. Containers that declare nothing get no new findings. (part of #416)
Screenplay (Release v4.79.0): A dependency the model has but the container doesn’t declare is a warning (PLAY0552), one per container and producer module, naming what to declare.
Screenplay (Release v4.79.0): A declaration nothing uses is information (PLAY0553), and two containers that declare each other get information (PLAY0556).
Screenplay (Release v4.79.0): Each container is held to its own declarations, including the slices of its sub-features. References whose owner is ambiguous never raise a warning.
Screenplay (Release v4.79.0): The MCP dependency-graph tool has a declarations view: each declaration with its status, and each counted edge as declared, provisional or undeclared, with evidence capped by evidenceLimit. declaration-details gains a dependencies view for modules and features. (part of #416)
Screenplay (Release v4.79.0): VS Code and the web editor list the declared-dependency findings and offer depends on in module and feature bodies. (part of #416)
Arc (Release v22.53.0): Analyzer ARCCHR0015 warns when a command’s Handle() returns a nullable event, directly or inside Task, ValueTask, Result or OneOf. A null event either succeeds without appending anything or fails with an unexplained error. A code fix rewrites the handler to Result<TEvent, ValidationResult> with a rejection. See ARCCHR0015. (#3036)
Screenplay (Release v4.78.0): Specification given, when append and then events can state their event source and stream with the child lines stream <Source>.<Stream> and, for a keyed stream, streamId = <value>. A then event can assert that it is unrouted with no stream. A routed given or when append states for, checked against the source’s identifier type. The executable model refuses these lines with PLAY0268 until a version admits event routes, so they can be authored, printed and checked now. (part of #457)
Screenplay (Release v4.78.0): New diagnostics: PLAY0547 for a malformed or misplaced route line, PLAY0548 for a route under when <Command>, PLAY0549 for a stream that doesn’t resolve or a stream id that doesn’t fit it, PLAY0550 for a missing or mistyped for, and PLAY0551 for a route that contradicts the command under test. (part of #457)
cli (Release v3.31.0): cratis screenplay generate --authoring-only-constructs also writes Arc constructs that are not executable yet: operations and the systems they use, event sources and streams with command routes, and reads and require recovered from Provide(). A document using them has no executable model. Providers other than Arc warn with CLI0014. (#262)
Screenplay (Release v4.77.0): The MCP App and the VS Code event model board can switch from the board to a dependency map. The map shows modules as columns in suggested story order and features inside them, with other bounded contexts as outer nodes. Each edge is labelled with its kinds and the number of slice pairs behind it. By default it shows the dependencies that shape the story, and toggles add the others. Selecting an edge lists its slice pairs and the references behind them; in VS Code each reference opens its source. The map can be used with the keyboard and a screen reader. In the MCP App it follows the current or proposed model. (part of #415)
Screenplay (Release v4.76.1): Completion offers only what the scope you are in can hold: the root, a module, a feature, each slice type, and the bodies of read models, reducers, forms, contributions, behaviors, personas, authentication, seeds, themes, UI profiles and layouts.
Screenplay (Release v4.76.1): An empty command expands into its identifier, the properties of the event it most likely produces, and the produces block, as ghost text and as a completion.
Screenplay (Release v4.76.1): Pressing Enter after a block header indents to the body, in the Monaco and VS Code editors.
Screenplay (Release v4.76.0): Modules and features can state what they depend on with depends on <Module>, depends on <Module>.<Feature> or depends on <SiblingFeature>, one target per line, after description. The statement is authoring metadata and does not change the executable model. (part of #416)
Screenplay (Release v4.76.0): Targets resolve inside out: sibling features first, then the siblings of each enclosing feature, then modules. A target that is the container itself, one of its ancestors or descendants, or that names nothing raises a warning (PLAY0554). A repeated target is kept once with a warning (PLAY0555).
Screenplay (Release v4.76.0): Declarations from several files accumulate. Layout expansion writes them only in the owning file. Renaming a module or feature through the workspace rename updates the targets that name it.
Screenplay (Release v4.75.0): Structure completion in the Monaco and VS Code editors: on an empty line inside a command, specification or form, ghost text suggests the produces block, the given/when/then skeleton or a field per command property, built from your own declarations.
Screenplay (Release v4.75.0): The VS Code extension registers the language keywords with the Code Spell Checker extension, so readmodel and the other constructs are no longer flagged as unknown words.
Arc (Release v22.52.0): Commands mark their event source identifier and route productions with for, using the same rules as Arc’s runtime. The generator reports ambiguous or unreadable identities and productions routed to another event source. (part of #2887)
Arc (Release v22.52.0): An event produced by exactly one unconditional, complete command production anywhere in the application is written inline as produces event, and the embedded event model board shows inline events. (part of #2887)
Arc (Release v22.52.0): Events carry their XML summary as description, their remarks as documentation, and a rename pin for generation-1 events whose stored name differs from the type name. (part of #2887)
Arc (Release v22.52.0): Unconditional Must(Method) validator rules become named rules that point to their implementation file, where no specification exercises the command. (part of #2887)
Arc (Release v22.52.0): Event scenarios become when append specifications, and specifications state the event source of their events with for. A scenario whose event sources cannot be stated faithfully is left out and reported. (part of #2887)
Arc (Release v22.52.0): Identifiers and values a handler creates with Guid.NewGuid(), and scalar and record command responses, are written as generated values and returns where the executable model admits them and specifications do not depend on them. (part of #2887)
Arc (Release v22.52.0): ScreenplayOptions.AuthoringOnlyConstructs (MSBuild CratisEmbeddedScreenplayAuthoringOnlyConstructs) also writes constructs that are not executable yet: operations and the systems they use, event sources and streams with command routes, and reads and require recovered from Provide(). (part of #2887)
AI (Release v7.13.0): IAIChatClients.For(purpose, target) gives a pooled chat client for an agent the application defines itself, dispatched through the same pool selection, concurrency limit, cooldown and usage recording. Applications that keep their agents in their own read models no longer need to resolve providers themselves.
AI (Release v7.12.0): IAIChatClients.For(purpose) hands out an IChatClient for an agent that goes through the same provider-pool dispatch, least-burnt member selection, per-provider concurrency limit, rate-limit cooldown and usage recording as ILanguageModel. It supports multi-turn, streaming and tool calls (wrap it with UseFunctionInvocation()). (#439)
AI (Release v7.12.0): IProviderChatClientFactory opens the vendor chat client for a configured provider, so the vendor SDK stays behind one seam.
Screenplay (Release v4.74.0): The TypeScript compiler package infers the same dependency graph as the .NET compiler and the MCP dependency-graph tool, so the boards can show it: slice edges by kind, implied module and feature edges, groups that depend on each other, unresolved references and a suggested story order. (part of #414)
Screenplay (Release v4.73.0): New MCP tool dependency-graph shows how slices, features, modules and other bounded contexts depend on each other, inferred from the model with no new language.
Screenplay (Release v4.73.0): Each slice edge has a kind: uses facts from, reacts to, decides from, asks, shows, used in specifications (hidden by default), or outside the model (contract imports).
Screenplay (Release v4.73.0): The tool implies edges between modules and features, including mixed levels, with counts and the slice references behind each edge.
Screenplay (Release v4.73.0): It reports groups that depend on each other.
Screenplay (Release v4.73.0): It suggests a story order that keeps the authored order unless a dependency forces a change. The suggestion is never applied. (part of #414)
Screenplay (Release v4.71.0): VS Code and the web editor now list PLAY0516 (a slice uses an event from a slice drawn after it) and PLAY0517 (modules or features that use each other’s events) as information in the problem list. Neither finding fails a build. (part of #413)
Components (Release v4.26.0): SchemaEditor has a layout prop. 'table' is the existing drill-down table and stays the default; 'tree' shows nested properties inline and applies every edit through onChange, with readOnly for display.
Components (Release v4.26.0): Concept-typed properties (concepts, saved as x-concept), a required toggle (allowRequired) and a key toggle (allowKeyProperty, saved as x-key, one key per object). The required and key toggles work in both layouts.
Components (Release v4.26.0): Extension points for products that attach their own features to a schema: header, footer, isPropertyProtected, validatePropertyName, onPropertyRenamed and onPropertyRemoved in both layouts; and, in the tree layout, renderPropertyLeading, renderPropertyAccessory, renderPropertyDetails, renderPropertyTypeBadge, getPropertyRowState, selection through selectedPropertyId and onPropertyClick, and a controlled mode with a callback for every edit.
Components (Release v4.26.0): New optional SchemaEditorLabels entries for the added controls. Existing labels are unchanged.
Components (Release v4.26.0): The property model and the schema conversion helpers (jsonSchemaToProperties, propertiesToJsonSchema, setKeyProperty, setRequiredProperty and the rest) are exported from @cratis/components/SchemaEditor.
Screenplay (Release v4.70.0): MCP read-workspace view=repairs and propose-repair now offer a typed repair for PLAY0516, a slice that uses an event from a slice drawn after it. The repair moves the producing feature, slice or module, or an import line, ahead of the consumer. When the order comes from a glob, it adds an explicit import of the producer’s file before the glob, which keeps importing new files. A repair is offered only when it fixes the finding without introducing new ones and leaves the model, identities and file placements unchanged; on models that do not compile to an executable model yet, that is proven on the source. (part of #413)
cli (Release v3.29.0): cratis direct login, logout, status and use <tenant> provide browser-based Direct sign-in, server-side token revocation, live identity status and tenant reauthorization. Sign-in uses the public cratis-cli client with authorization code and PKCE, and discovers the issuer from Direct or accepts an explicit --issuer. (#205)
cli (Release v3.29.0): Direct credentials are isolated from Chronicle contexts and stored in the operating system credential manager. Unix users can explicitly choose owner-only plaintext storage with --insecure-file-store; status and logout honor each credential’s recorded store without exposing tokens. (#205)
cli (Release v3.29.0): Direct authentication validates callback state and issuer, binds stored credentials to their issuer, serializes token refresh across processes and bounds HTTP requests. Issuers require HTTPS except for loopback development servers. (#205)
Screenplay (Release v4.69.0): Report when a slice uses an event declared in a slice drawn after it on the event model board: PLAY0516 for a projection or named reaction trigger whose event comes from later in the authored order, and PLAY0517 once for a group of modules or features that use each other’s events. Both are information diagnostics, so --warnaserror still passes, and the C# and TypeScript compilers report the same findings. (part of #413)
Chronicle.Go (Release v0.8.0): Projections can build children of a derived-type family: a children collection of an interface with exactly one registered derivative uses that concrete type for its fields, key, parent key and mapping tags, and writes _derivedTypeId on every child From, so the family codec reads the child back even when the kernel adds it from a keyed update after removal or before creation; the C# client stamps only the creating event. The fluent projections.Children accepts the same family with the derivative’s builder, and a derivative’s key, no-auto and not-projected tags do not turn another read model that holds the family as a whole property into a projection. See project derived children. (#27)
Arc (Release v22.51.0): Add Cratis:Arc:Introspection:IdentityDiscovery to disable user, tenant and identity-schema discovery independently of the catalogs. Set it and Enabled to false to remove all discovery endpoints without discovery authentication checks or exposure warnings, while keeping /.cratis/me available. (#3037)
Chronicle.TypeScript (Release v6.50.0): Events can carry structured named tags (NamedTag, a validated name and value) with the namedTags append option, per entry in appendMany, and inside units of work. Read them on EventContext.namedTags for reads and reactor and reducer deliveries. Appends without named tags are unchanged. (#206)
Chronicle.TypeScript (Release v6.50.0): Single appends support named tags with registered event sources. Batches and unit-of-work commits reject non-empty named tags combined with any registered-source entry with NamedTagsWithRegisteredEventSourceNotSupported, preventing routing loss until the kernel limitation is resolved. Empty named-tag arrays remain supported.
Chronicle.TypeScript (Release v6.50.0): EventScenario and ReadModelScenario reject non-empty named tags; ReactorScenario validates and records named tags on returned side effects.
Chronicle.Go (Release v0.7.0): Generated contracts/alerts and contracts/eventsources packages, plus the EventSource fields on append requests and event contexts, from the Chronicle 19.32.3 protocol. The SDK does not set EventSource or expose alerts and event-source registration yet.
Screenplay (Release v4.68.2): The canonical corpus includes a source rejection vector for a generated value supplied as specification input. (#421)
Screenplay (Release v4.68.0): Generated command values are admitted as ESM v7, selected only by generated properties, responses, generation fixtures or return expectations; unchanged models retain their ESM version, bytes and revision. Reference execution uses deterministic fixtures and reports Unsupported(IdentityAllocation) when reached generation has no fixture. Consumers must explicitly admit or reject v7 separately for reading, reference execution, rendering and reverse recovery; a package upgrade does not grant admission. (part of #300)
Screenplay (Release v4.68.0): Scalar and authored-order record command responses are available only on acceptance, with then returns assertions, paged MCP export, editor guidance and Invoicing examples. Operations, streams, handlers and exact mode remain independently unadmitted; UI response-name continuations and end-to-end navigation require downstream support. (part of #303)
Screenplay (Release v4.68.0): Generated values do not exist yet when a command is authorized or validated: policies, the implicit subject, rules and requirements that reference one report PLAY0273, and a generated property on a concept with validation rules reports PLAY0268. (part of #300)
Screenplay (Release v4.68.0): SemanticExecutionRequest.GeneratedValues supplies deterministic generated fixtures, and SemanticAccepted.Response exposes the accepted command response. RegisterProjectCorpus.V7 provides source-backed v7 conformance vectors, with expected responses in CanonicalCorpusSpecificationExpectation.Response. (part of #309)
Chronicle.Go (Release v0.6.0): Binary values: []byte fields (and named byte-slice types, with one optional pointer) are written as base64 strings that match the C# client, including + escaped as \u002B, "" for empty values and omission of nil values. Supported shapes are fields in event payloads, including fields inside nested objects, top-level read-model fields, and From AutoMap copies between binary fields (part of #64)
Chronicle.Go (Release v0.5.0): Configure trusted gRPC stats handlers on SDK-owned connections, including reconnects, while keeping handler lifetimes application-owned. (#53)
AI (Release v7.11.0): A rule that .cratis/ holds configuration and the shared AI corpus only: Screenplay models, source, generated code, specifications and documentation are never produced there.
Screenplay (Release v4.67.0): Without a project, the Screenplay MCP server now works in Documents/Screenplay in your home folder, creating it on demand, so Claude and ChatGPT desktop need no model folder. The .play files are ordinary files there.
Screenplay (Release v4.67.0): When the host offers a project root, the server serves the folder already holding the project’s .play files, else its Source or src folder, else a new Screenplay folder in the project.
cli (Release v3.28.0): cratis screenplay mcp now finds the model itself. It serves the folder that already holds the project’s .play files, otherwise Source/ or src/, otherwise a new Screenplay/ folder at the project root. It also works in a project with no .cratis/ai.json.
Chronicle.Go (Release v0.3.0): Capture webhook sources accept inbound authorization: captures.Webhook(path, captures.WithBasicAuth(...)), WithBearerToken or WithOAuth, readable through Source.Authorization() and Definition.Authorization(). Authorization never appears in the capture declaration text, and is redacted from fmt and log/slog output, including when held in private fields (part of #37)
Chronicle.Go (Release v0.2.0): Connection lifecycle hooks: WithOnConnected and WithOnDisconnected register ConnectionHook callbacks that receive a ConnectionEvent (generation, connection ID, selected address and cause) on every connect, reconnect and close. Hooks run on a client-owned dispatcher in transition order, never delay reconnects, contain panics and always pair a delivered Connected with exactly one Disconnected, including on Close (part of #62)
Chronicle.Go (Release v0.2.0): Custom load balancing: WithLoadBalancer accepts your own LoadBalancer that picks the endpoint for every connection attempt, including SRV-discovered candidates. A failed selection returns *LoadBalancerError and is retried with the normal reconnect backoff. The client borrows the balancer and never closes it, and rejects it when combined with a loadBalancer= connection-string option or WithGRPCConnection (part of #62)
Arc.Go (Release v0.1.0): Command and query pipelines with execution contexts, service scopes, command filters, response value handlers and Arc-shaped results, usable without a dependency-injection container or a Chronicle connection (#3) (#6) (#10) (#11) (#16)
Arc.Go (Release v0.1.0): Flat command operations with commit-aware compensation, plus traditional-handler envelopes and request-merge adaptation (#30) (#35)
Arc.Go (Release v0.1.0): Application builder and net/http hosting with endpoint discovery, following Arc’s snapshot command and query HTTP contracts; static files and an SPA fallback are served through Builder.Handle (#17) (#36)
Arc.Go (Release v0.1.0): Observable queries over Server-Sent Events and WebSocket, the query hub, emission guards and ownership verified across two application instances (#21) (#27)
Arc.Go (Release v0.1.0): Validation, authentication, authorization, identity and tenancy, including scoped policy and validator factories (#7) (#11)
Arc.Go (Release v0.1.0): Validation severity filtering, query paging and sorting metadata, and paging metadata that is cleared when HTTP publication fails (#28)
Arc.Go (Release v0.1.0): Test scenarios and a task-board HTTP conformance host for specifying command and query behavior (#18)
Arc.Go (Release v0.1.0): Source preview: Chronicle integration (github.com/cratis/arc.go/integrations/chronicle) with a shared provider for Chronicle deliveries and Arc operations, command operations with compensation, reactor-issued commands, and optimistic decision reads (#14) (#19) (#29) (#31)
Arc.Go (Release v0.1.0): Source preview: MongoDB integration (github.com/cratis/arc.go/integrations/mongodb) with read-model rendering, concept codecs, snapshot queries and bounded change-stream observation (#22)
Arc.Go (Release v0.1.0): Source preview: arc-gen generates typed Handle, Provide, query, validator and policy adapters and TypeScript proxies for the Cratis frontend packages, including Int32 enum parsers and validator and policy registration directives (#13) (#20) (#32)
Arc.Go (Release v0.1.0): Source preview: arc-gen writes an OpenAPI 3.1 document and an opt-in Screenplay .play metadata file; both are files only, with no HTTP route and no embedded viewer (#24) (#37)
Arc.Go (Release v0.1.0): Source preview: arc-vet diagnostics that report Go authoring mistakes beyond generation-time signature checks (#34)
Arc.Go (Release v0.1.0): Backend operation diagnostics and protected query health (#33)
Arc.Go (Release v0.1.0): Source preview: recipes for mounting Arc under Chi, Gin and Echo, golang-jwt authentication, browser-origin CORS and CSRF protection, OpenTelemetry tracing and
AI (Release v7.9.0): A completeness self-check (“do not cut corners to save tokens or effort”), a per-turn protocol and fuller phase-transition and reasoning-note guidance in cratis-screenplay-modeling-lifecycle (#497)
AI (Release v7.9.0): The business-question lens and an automation-chain audit as review checks in cratis-screenplay-model-review, which now has 89 checks (#497)
AI (Release v7.9.0): Build prompts and conformance checklists for hand-written slices in cratis-application-slice-conformance, including a check that the running application really subscribes each reactor (#497)
AI (Release v7.9.0): A candidate inventory and UI-walk progress reporting in cratis-screenplay-legacy-extraction (#497)
AI (Release v7.9.0): Good and bad scenario forms, with a runnable invoicing example and a design-mode companion that declares its stored-state rules, in cratis-screenplay-scenario-coverage (#497)
AI (Release v7.9.0): An Acknowledgments section in the README crediting Martin Dilger, Nebulit GmbH and TrogonStack (#497)
AI (Release v7.8.0): IAIProviderCapacities reports an AIProviderCapacity for any provider: its usage windows (5-hour, daily, weekly or monthly, each with the share used and when it resets), one Headroom figure from 0 to 1, CanStartWork, and AvailableAgainAt. Claude subscriptions, ChatGPT/Codex subscriptions, GitHub Copilot and the Z.AI coding plan report their real windows. API-key providers fall back to the configured usage capacity, or count as unmetered.
AI (Release v7.8.0): The CapacityFor(providerId) query and its @cratis/ai proxy (Providers/Capacity) let a frontend show a provider’s windows and headroom.
AI (Release v7.8.0): ICanReportAIProviderCapacity lets an application add a capacity source for another vendor.
AI (Release v7.8.0): New options AIProviderOptions.MinimumHeadroomToStartWork (default 0.02) and CapacityFreshness (default 5 minutes). Observations are cached, and the last good reading is kept when a vendor fails to answer.
AI (Release v7.8.0): ProviderRateLimit.ResetIndicatedBy(reason, now) reads the reset time out of a limit message, such as “resets Oct 9, 2am (UTC)” or Claude Code’s |<epoch> suffix.
AI (Release v7.8.0): PoolSelectionData.HeadroomByProvider ranks pool members by remaining headroom.
AI (Release v7.7.0): Ten Screenplay method skills, which you install with the cratis/screenplay profile:
AI (Release v7.7.0): cratis-screenplay-modeling-lifecycle: phases, gates, verdicts and the model-first decision.
AI (Release v7.7.0): cratis-screenplay-toolchain: versions, tools and diagnostics.
AI (Release v7.7.0): cratis-screenplay-legacy-extraction
AI (Release v7.7.0): cratis-screenplay-render-and-gap-fill
AI (Release v7.7.0): cratis-application-slice-conformance checks hand-written or gap-filled slice code against its contract, element by element and spec by spec. It installs with cratis/specifications/dotnet.
AI (Release v7.7.0): Three agents for model-level work: Screenplay Modeler, Screenplay Reviewer (read-only) and Screenplay Renderer. They use your session’s model.
AI (Release v7.7.0): cratis-arc-react-page maps Screenplay screens, forms and queries to Arc React pages, and traces every field on screen to its source.
Screenplay (Release v4.66.0): An experimental, opt-in VS Code bridge offers the C# PLAY0166 repair (declare a missing produced event) and the PLAY0478 repair (explicitly route to the command identifier) through a configured, trusted Screenplay executable. Each repair shows read-only previews of every source and identity change and is applied only after an explicit final confirmation. (part of #341)
Screenplay (Release v4.66.0): Repairs are refused while affected files have unsaved or untitled changes, and a stale review is refused at Apply time when source files, identity state or referenced attachments changed on disk, even if no file notification arrived. (part of #341)
Screenplay (Release v4.66.0): When an Apply outcome is uncertain, the extension preserves your typing and never retries; a definite refusal after dispatch is treated as uncertain too. Read-only inspection of the retained root and explicit consent through Screenplay: Resume repairs after inspection allow the next repair to start a fresh, revision-checked session without reusing old tokens or reviews. (part of #341)
Screenplay (Release v4.66.0): The VS Code guide documents how to enable and use the repair bridge, inspect recovery state and resume repairs safely. (part of #341)
Screenplay (Release v4.65.0): A named validation rule on a command can carry an implementation block with ordered hint lines and, optionally, the rule’s file or tagged code fence. A rule with only hints, or an empty block, records pending implementation intent. (part of #307)
Screenplay (Release v4.65.0): Pending rules are valid source but report PLAY0268 when bound. A rule whose implementation is attached binds exactly as before, and adding, editing or reordering its hints does not change the executable model, requirement identity or content hash. (part of #307)
Screenplay (Release v4.65.0): Both compilers, the Monaco and VS Code editors, MCP inventories and typed authoring understand the new block, and workspace edits and refactorings keep each pending rule’s obligation with its rule or refuse the edit. (part of #307)
Chronicle.Go (Release v0.1.0): Client foundation with pinned Chronicle contracts, connection supervision and registration lifecycle (part of #3)
Chronicle.Go (Release v0.1.0): Event-store cache eviction with (*Client).EvictEventStores(), borrowed scoped facades, client-wide slog routing and guarded two-phase client preparation (part of #62)
Chronicle.Go (Release v0.1.0): Fundamentals.Go concepts and shared scalars in event serialization (part of #13)
Chronicle.Go (Release v0.1.0): Strict ordered unit of work with participant and owner (part of #14)
Chronicle.Go (Release v0.1.0): Unique and event-type constraints with removers (part of #15)
Chronicle.Go (Release v0.1.0): Event-level model-bound declarations for unique, subject, index and descriptor metadata (part of #28)
Chronicle.Go (Release v0.1.0): Default JSON naming aligned across serialization, schemas and projection paths (part of #29)
Chronicle.Go (Release v0.1.0): Registered serialization codecs, including declared Int32 enum codecs and derived schema parity (part of #64)
Chronicle.Go (Release v0.1.0): Typed decoding of read-model paths through registered serialization plans (part of #50)
Chronicle.Go (Release v0.1.0): Read-model catalog registration, one-shot reads, collections and bounded reducer reads (part of #20)
Chronicle.Go (Release v0.1.0): Projections with model-bound and fluent declarations: mappings, arithmetic, global mappings, children, joins, nested objects, removals, context tags and typed nullable clears (part of #26)
Chronicle.Go (Release v0.1.0): Projection variants, global handlers, recursive children, source inference and preview (part of #27)
Chronicle.Go (Release v0.1.0): Typed projection initial values and artifact labels (part of #60)
Chronicle.Go (Release v0.1.0): Runtime artifact registration with atomic catalog publication and reconnect retention (part of #63)
Chronicle.Go (Release v0.1.0): Convention-driven reactors with replay policies, returned effects, rich effects and reliable delivery (part of #30)
Chronicle.Go (Release v0.1.0): Convention-driven reducers with nullable state, passive reads and replay lifecycle callbacks (part of #31)
Chronicle.Go (Release v0.1.0): Historical event generations with bidirectional migrations (part of #32)
Chronicle.Go (Release v0.1.0): Read-model watches, materialized windows and read-model reactors (part of #33)
Chronicle.Go (Release v0.1.0): Admitted decision guards with owned commits for protected decision reads (part of #34)
Chronicle.Go (Release v0.1.0): PII and encrypted metadata with the complete subject-key lifecycle (part of #35)
Chronicle.Go (Release v0.1.0): Event seeding after observers start without duplicate startup appends (part of #36)
Chronicle.Go (Release v0.1.0): Event store subscriptions, webhooks, external services and captures (part of #37)
Chronicle.Go (Release v0.1.0): Public scenario test kit for events, reactors and read models, with strict projection subscriptions (part of #38)
Chronicle.Go (Release v0.1.0): Audited revise and redact operations for event history (part of #40)
Chronicle.Go (Release v0.1.0): Observer and jobs administration with explicit completion outcomes (part of #59)
Chronicle.Go (Release v0.1.0): Typed contextual and usual-action pattern queries (part of #61)
Chronicle.Go (Release v0.1.0): Ordered event enrichment, audit providers and a stable identity rename (part of #65)
Chronicle.Go (Release v0.1.0): Append notifications with origin identity and typed callback-based origin resolution (part of #47)
Chronicle.Go (Release v0.1.0): Checked sequence-number helpers (part of #18)
Screenplay (Release v4.64.0): A top-level numbers exact preamble opts a file into exact numbers; its numbers are read, printed and transported as bounded decimals without rounding, in both the C# and TypeScript compilers. (part of #285)
Screenplay (Release v4.64.0): New diagnostics for exact numbers: unknown, repeated, misplaced or nested numeric directives, numbers outside the exact decimal range, and files or import barrels that disagree on numeric mode (PLAY0508–PLAY0513). (part of #285)
Screenplay (Release v4.64.0): Proposed decision 0024 describes the exact numeric source mode and its path to ESM v7. (part of #285)
Chronicle (Release v19.32.0): Open alert incidents are materialized from the recorded alert transitions into incident rows stored next to the System event sequence, for MongoDB, SQL (SQLite, PostgreSQL, SQL Server) and in-memory storage. Redelivered or out-of-order transitions never overwrite newer state, and a cleared incident cannot be resurrected by a delayed raise (part of #4424)
Chronicle (Release v19.32.0): GetOpenIncidents, GetOpenIncident and GetOpenIncidentCounts queries on the new Alerts service, scoped to an affected event store and optionally a namespace, with filtering by observer, condition and minimum severity, bounded keyset paging and counts grouped by namespace, condition and severity (part of #4424)
Chronicle (Release v19.32.0): Every incident query reports whether the incident view is Ready, CatchingUp or Degraded, so an empty result is never mistaken for “no incidents” while the view is still catching up or has failed partitions (part of #4424)
Stage (Release v4.77.0): The compliance rendering reference explains the mapping, the identity rule and its surrogate-identifier fix, and why concepts should be marked before their events are first published. Models without compliance render exactly as before.
AI (Release v7.35.0): Synced with Arc 22.76.0, Chronicle 19.51.0, Fundamentals 7.23.0, Specifications 4.1.1, Orleans 1.16.3, Components 4.26.4, Chronicle.TypeScript 6.51.0, Arc.TypeScript 0.57.2, Chronicle.Kotlin 6.13.0, Arc.Kotlin 7.7.0, Chronicle.Elixir 3.10.2, cratis CLI 3.53.1 and Chronicle.Mcp 2.0.0; each skill’s verified sources name the release read (#620)
AI (Release v7.35.0): The standalone Screenplay pin moves to 4.141.0 with its published contract; Stage 4.74.0 to 4.76.0 capabilities are taught as standalone Stage, since cratis CLI 3.53.1 still bundles Stage 4.73.1
AI (Release v7.35.0): The Chronicle MCP skill states the exact effect of each Chronicle.Mcp 2.0.0 tool, its read-only default and the mutation profile, and warns that it targets the active cratis context
AI (Release v7.35.0): The CLI operations guard treats observers remove and observers clear-partition-quarantine as mutating commands
AI (Release v7.35.0): Concurrency guidance teaches decision reads (IStreamReads, [ProtectedDecision] with DecisionRead<T>, IDecisionReads) instead of advisory read-model injection
AI (Release v7.35.0): Scene packages are named @cratis/scene.* in the Stage scaffold tables
Arc (Release v22.76.0): Cratis.Screenplay and @cratis/screenplay-language are updated to 4.139.0. (#3175)
Screenplay (Release v4.141.0): Models with protected concepts now bind and run their specifications instead of failing with PLAY0268; markers do not change reference-evaluator outcomes, and free-text reasons stay report-only (part of #141)
Screenplay (Release v4.141.0): PLAY0268 now refuses compliance on enum concepts and on concepts used as event-source or stream identities, and refuses an event that holds a personal or subject-scoped secret value together with an explicit subject mark until subject lineage is admitted (part of #141)
Screenplay (Release v4.141.0): The MCP readiness text and editor hover documentation describe concept compliance as executable in ESM v13 (part of #141)
Stage (Release v4.76.0): The Host world rebuilder maps a stored enum number to the member that declares it, so events stay readable when numbered members are reordered. Unnumbered enums keep declaration-order numbers, and unknown numbers, fractions and undeclared names are still refused. (#296)
Stage (Release v4.76.0): The rendering reference explains explicit enum member numbers and keeps the append-only rule for unnumbered enums; the Docker and renderer-target guides list Screenplay 4.139.0 and ESM v1–v12. (#296)
AI (Release v7.34.1): The Screenplay, Stage and Cratis skills no longer restate the current Stage scaffold dependency pins (Arc, Chronicle, Components, Scene, @cratis/arc) or the CLI’s bundled Cratis.Arc.Screenplay version; they point to the toolchain and rendered-application version tables, so the next CLI or Stage release only updates those tables. Version-qualified claims such as “refused at Stage 4.73.1” stay as they are
AI (Release v7.34.0): Capability statements across the Screenplay skills match Screenplay 4.139.0, CLI 3.53.1 and Stage 4.73.1: list and observable queries bind and run, descriptions render as code comments, ownership claims on text, Uuid, Date and DateTime subjects render, navigate to is the destination after a successful command, and public events and contributions follow the released language (part of #611)
AI (Release v7.34.0): A reaction that both appends events and runs commands stays one modeled reaction; the skills explain that Arc 22.72.0 runs it, that Stage 4.73.1 refuses it, and that a hand-written reactor needs Arc 22.72.0 or later (part of #611)
AI (Release v7.34.0): Legacy extraction warns that generate and conform evaluate projects through MSBuild, so they run against a trusted clone rather than the live legacy checkout, and describes Prologue interpret --no-llm (part of #611)
AI (Release v7.34.0): Attribution for the agentic-engineer material now records the explicit consent of Martin Dilger and Nebulit GmbH (part of #611)
AI (Release v7.33.0): The Screenplay toolchain skill pins the standalone Screenplay compiler to 4.139.0 and refreshes the published contract it checks against
cli (Release v3.53.1): Bundles Stage 4.73.1 and runs cratis/stage:4.73.1 by default. The release fixes the running Stage serving the Scene document with the .NET spelling of each enumeration, which left a dialog destination opening nothing. (part of #284)
Arc (Release v22.70.0): The Screenplay generator now targets Cratis.Screenplay 4.135.0 (NuGet and npm).
Arc (Release v22.70.0): An encryption scope other than the default is kept. A concept marked [Encrypted(EncryptionScope.Namespace)] or [Encrypted(EncryptionScope.Global)] together with [NotAudited] is written as secret scope namespace|global when authoring-only constructs are enabled. In the default executable output it stays a bare secret, and the new SP0061 diagnostic names the scope the document does not state. (#3089)
Arc (Release v22.70.0): [PII] on a property whose type is not a concept (for example [PII] string Email) is now reported with SP0062 instead of being dropped silently. Screenplay classifies concepts, so introduce a personal-data concept to carry the marking. (#3089)
Arc (Release v22.70.0): When [PII] on one property promotes its concept to pii everywhere, the new SP0063 diagnostic names the other uses of that concept that were not marked. (#3089)
Arc (Release v22.70.0): The SP0058 and SP0059 messages and the compliance section of the generator documentation now use the current pii and secret terms. (#3089)
Arc (Release v22.70.0): Generator verification tolerates a known Screenplay admission-limit diagnostic only when the loaded Screenplay compiler still lists its code as an active error, so a retired or downgraded code fails verification instead of being silently accepted. (#3099)
cli (Release v3.53.0): Bundles Stage 4.73.0 (Scene 4.21.0, Screenplay 4.137.0) and runs cratis/stage:4.73.0 by default. The release brings module-level and screen-level navigation contributions, a screen’s place in the module and feature hierarchy, toolbar items that open their destination, presentation hints (icon, text, both), and the Scene host’s outlets, dialogs and deep links. (part of #284)
Stage (Release v4.73.0): The Stage no longer keeps navigation state of its own: the primary screen, nested outlets, the open dialog and the #/Screen?parameter=value address belong to Scene’s useSceneHistoryNavigation over createHashSceneHistory. An address that stands for an outlet destination restores the whole composition, and closing a dialog goes back to where it was opened from. (part of #237)
Stage (Release v4.73.0): Navigation contributions carrying id, icon, presentation or a destination are no longer refused with STAGE-SCENE-UI-001; Scene 4.21.0 honours them.
Stage (Release v4.73.0): The generated-React browser harness proves it against the generated application: the module-level entry, a screen no entry lists nested under its module and feature, the toolbar with an icon-only item and a placement hint, and a toolbar dialog that opens and closes (70 assertions, 0 blocked).
Stage (Release v4.73.0): Moves to Scene 4.21.0 and Screenplay 4.137.0. The frozen default scene, the frontend shell digest and the screens vector ledger are re-pinned, and the canonical typed composition is translated aga
cli (Release v3.52.0): The CLI bundles Stage 4.72.0 (Scene 4.20.0). cratis run starts cratis/stage:4.72.0, which, being a built frontend, renders only the three shipped packages; the documentation says so and points at cratis render --package-set for custom packages. (part of #284)
cli (Release v3.52.0): An unknown package in a ui profile (CLI-RENDER-007) now says a custom runtime package has to be approved with --package-set. (part of #284)
Chronicle (Release v19.49.0): Every-event mappings (FromEvery, FromAll, model-bound [FromEvery], and PDL every) now also apply to events handled only by child or nested-child collections. The mapped values are written to the parent read model the child belongs to. Opt out with ExcludeChildProjections() in the fluent builder or exclude children in PDL; model-bound [FromEvery] always includes children (#4725)
Stage (Release v4.72.0): Rendered applications and the live Stage use Scene 4.20.0 (@cratis/scene.* and Cratis.Scene.*), which publishes the approved package set loader. (part of #236)
Stage (Release v4.72.0): Verification/generated-react-browser/run.sh runs another scenario script when STAGE_GENERATED_REACT_SCENARIO names one, so a rendered application with a custom package can be held to its own assertions. (part of #236)
Scene (Release v4.21.0): extractNavigationItem reads the whole authored item - id, icon, presentation, destination and hierarchy - instead of only the label, target, order and group. (part of #74)
Screenplay (Release v4.136.0): SemanticExecutionPlan.Compile(model, selectedSlices) accepts an empty selection. It returns a plan that blocks only on application-level admission issues. Every slice issue is reported in UnselectedIssues, and the reference evaluator refuses execution that reaches those declarations. A scoped render whose slices were all removed no longer fails on unrelated slices. An unknown slice id is still refused. (#661)
Stage (Release v4.71.0): Stage now builds against Screenplay 4.133.3 and Chronicle 19.45.0, and the Stage Host image runs cratis/chronicle:19.45.0-development. (#327)
Stage (Release v4.71.0): Generated applications pin Cratis and Arc 22.68.0, an explicit Cratis.Chronicle 19.45.0 client and a cratis/chronicle:19.45.0-development kernel image. Apart from those version strings the scaffold is unchanged. (#327)
Stage (Release v4.71.0): Generated read-model and query specifications dispose their ReadModelScenario, which is disposable from Chronicle 19.45.0, so generated applications keep building warning-free. (#327)
Stage (Release v4.71.0): A navigation contribution that sets id, icon, presentation or a destination is refused with STAGE-SCENE-UI-001, naming the field, because the pinned Scene runtime does not honor it yet. Rendering these fields is tracked in https://github.com/Cratis/Stage/issues/329. (#327)
AI (Release v7.30.0): The toolchain skill states that ESM v10 is released and frozen (decision 0066), that Screenplay 4.135.0 selects ESM v11 for exact whole-number literals while numbers exact and enum member numbers stay unadmitted, and that concept generation strategies (decision 0054) are not implemented yet (#593)
AI (Release v7.30.0): The pinned standalone Screenplay tool and published contract move to 4.135.0, and the pinned cratis CLI to 3.50.0, whose default renderer (Stage 4.67.0) applies case tables and whole numbers as long from ESM v8 (part of #593)
cli (Release v3.51.0): cratis render --scope no longer stops on execution-plan problems (PLAN-*) in slices outside the scope: they are reported as warnings naming the declaration, and only problems in the selected slices or application-level declarations block. A scope whose slices were all removed still re-renders to clean up its files. The CLI uses Screenplay 4.134.0 (#247)
cli (Release v3.51.0): cratis render refuses models whose navigation contributions declare id, icon, presentation, group or destination with CLI-RENDER-015, instead of rendering without them, until the bundled Stage renderer supports them (#247)
Chronicle (Release v19.48.0): In an opted-in projection, an event type named in the projection declaration language without a generation means the latest generation registered when the projection is registered, and the projection stays on that generation. To use a specific generation, declare the projection with the .NET projection builders (part of #4710)
Chronicle (Release v19.48.0): Registering an opted-in projection fails when it names two generations of the same event type, the same rule that applies to opted-in reactors and reducers (part of #4710)
Arc (Release v22.69.0): QueryScenario.Perform returns the first result of a query that returns ISubject<T> or ISubject<IEnumerable<T>>, the same result a plain HTTP request gets, instead of throwing StreamingQueryNotSupported. (#3153)
Arc (Release v22.69.0): Disposing a QueryScenario also ends its observations, after any startup and in-flight processing have settled. QueryObservation.Dispose() starts disposal without waiting; use DisposeAsync() or dispose the scenario to wait for cleanup. (#3153)
cli (Release v3.50.0): cratis render admits Screenplay ESM v9 and v10 models. Constructs the bundled Stage renderer does not support yet are refused with their own diagnostic instead of a generic version error: public events and event-target projections and reducers (STAGE-ESM-032), foreign origins and event-source captures (STAGE-ESM-033), reaction system identity (STAGE-ESM-034), reaction observer filters (STAGE-ESM-035) and per-production route overrides (STAGE-ESM-036). Reducer observer filters render. ESM v11 and later are still refused with CLI-RENDER-004 (#303)
AI (Release v7.29.0): The backend application profiles (cratis/application/csharp, typescript, elixir, kotlin, java, arc-chronicle, arc-only and chronicle-dotnet) now include the Screenplay method and language skills and the Screenplay MCP server, so model-first work can be proposed and done in application repositories. Installing them does not opt a repository in: that still takes a committed .play model under the model root or a configured mcpServers.screenplay.root, and with Cratis CLI 3.46.1 or later the server creates no model folder until the first write (#495)
AI (Release v7.29.0): In Pi, when Screenplay comes in only through an application profile and no model root is configured, a missing Cratis CLI, a CLI older than 3.46.1 or a server that fails to start leaves the Screenplay tools inactive with one notice instead of an error; selecting cratis/screenplay (or a profile that already included it) or configuring a root keeps startup errors visible (#495)
AI (Release v7.28.1): The reactor rules and the reactor, slice-specification and C# specification skills teach the Chronicle 19.46.0 ReactorScenario behavior: a reactor handler’s read-model parameter must be seeded, or declared absent with Given.ForEventSourceId(id).NoReadModel<T>(), otherwise the scenario throws ReadModelNotSeededForReactorScenario naming the type and key; a handler that throws synchronously surfaces its own exception; and EventContext.Occurred defaults to UTC. They no longer say the read model arrives as null (#599)
Chronicle (Release v19.46.0): EventContext.Occurred defaults to UTC (DateTimeOffset.UtcNow) when no time is given, matching the time the kernel stores. Events seeded into ReadModelScenario and ReactorScenario, and the event context returned when you append without an explicit time, now carry a +00:00 offset instead of the machine’s local offset. The instant is unchanged (#4571)
AI (Release v7.28.0): The pinned standalone Screenplay tool and published contract move to 4.131.0, and version statements across the Screenplay skills separate the current pins (CLI 3.46.1 bundling Screenplay 4.130.0 and Stage 4.52.0) from historical probes (#592)
AI (Release v7.28.0): A skill may carry three to five evaluation tasks instead of exactly three (part of #591)
Screenplay (Release v4.133.4): The browser native-controls harness expects the authored navigation label and the Workspaces > Tracking hierarchy, and reaches the list screen through that navigation link. Against CLI 3.48.0 and cratis/stage:4.67.0 it passes 52 assertions with no blockers. (part of #173)
Orleans (Release v1.16.3): The jobs documentation now explains what happens to a job step’s state when the step succeeds, fails, is stopped or is removed, that PerformStep works on a snapshot of the state, and how to deliver outside input such as worker callbacks to a running job through the job’s own grain. See https://github.com/Cratis/Orleans/blob/main/Documentation/concepts/jobs.md (#66)
cli (Release v3.48.0): The CLI bundles Stage 4.67.0 and Screenplay 4.131.0. (part of #284)
Chronicle (Release v19.45.0): A reducer with no dispatchable methods is no longer registered with the kernel. The client logs a warning naming the reducer and why each reducer-like method was skipped, and completion waits on that event sequence no longer time out waiting for it (#4726)
Screenplay (Release v4.133.3): Specification cells in the MCP app and the VS Code board show only the item cards. The values, the caller and the reason for an expected error appear in a hover card, instead of as loose text under each card.
Stage (Release v4.67.0): A model that authors no navigation entries keeps the flat list of screens as the menu. (part of #237)
Chronicle (Release v19.44.0): In ReactorScenario, a reactor that declares [EventSourceType], [EventStreamType] or [FromEventSource<TSource>(stream)] now handles only the given events that match its filter, as it would against a running kernel. A filtered reactor no longer handles events given without OnStream unless the default route matches its filter. Give those events with OnStream on the route the reactor listens to. Tag filters are not applied in the scenario
AI (Release v7.27.2): The screens guidance separates the executed vector (CLI 3.43.0, Stage 4.52.0, Scene 4.15.0) from packages published since (Scene 4.17.0, Screenplay 4.133.1, Stage 4.64.0, CLI 3.46.1, Studio 0.152.2), and no longer calls the newer ones the verified latest. (part of #536)
Screenplay (Release v4.133.2): ESM v10 is now listed as released. It first shipped in Screenplay 4.125.0, and its contract includes reaction system identity, production route overrides and observer from filters. The interoperability version table, MCP readiness text, editor help and sample notes no longer call it claimed or unreleased. A consumer that admits v10 must admit all three features. See https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/interoperability.md (#647)
Screenplay (Release v4.133.2): Decision 0054 (concept generation strategies and freshness) and decision 0065 (explicit enum member numbers) are accepted. Neither is implemented yet. (part of #615) (part of #643)
Stage (Release v4.65.0): STAGE-SCENE-ACTION-001 and STAGE-SCENE-INTERACTION-001 now refuse only guards Stage cannot evaluate: anything other than item.<field> compared with a literal (==, !=, >, >=, <, <=, contains, startswith) combined with and and or, and any fallback other than hidden or an execute that names a command. Such a guard is still refused in runnable rendering, in the Scene a running Stage serves, and by the frontend runtime, which shows the action disabled with the diagnostic. See Guarded actions and interactions. (part of #236)
Stage (Release v4.65.0): A navigation started by an interaction is a step the browser can go back from, and its arguments become the target screen’s parameters. (part of #237)
cli (Release v3.47.0): The CLI uses Stage 4.62.0, and cratis run starts the matching cratis/stage:4.62.0 container. That container’s default engine refuses event sources, streams and routes with STAGE-ESM-030, so render routed models with cratis render (#290)
Scene (Release v4.18.0): validateValue checks an Object value that has properties field by field: it must be a record, every described field must fit its descriptor, required fields must be present and a field the descriptor does not describe is refused. An Object without properties still accepts any record or array. (part of #70)
Scene (Release v4.18.0): validatePackageBundle checks nested descriptors - duplicate fields, collections without item descriptors and enums without choices - at every depth, including inside collection items. (part of #70)
Scene (Release v4.18.0): Icon diagnostics also check icon fields inside a described Object value. (part of #70)
Screenplay (Release v4.133.1): The dependency map now shows the same Cratis logo and rounded toolbar as the board, in the same place, with its content kept clear of both.
Screenplay (Release v4.133.1): The map’s edge level and dependency kinds moved from a bar above the map into the View button, so the board and the map each have their own view settings.
Screenplay (Release v4.133.1): The toolbar buttons are fully rounded to match the toolbar, and property tooltips stay next to the card they describe, from @cratis/event-models 0.152.0.
Stage (Release v4.64.0): Stage builds against Scene 4.16.0: the Cratis.Scene.Engine and Cratis.Scene.Model packages, the Stage frontend’s @cratis/scene.* packages, and the @cratis/scene.* version a generated application pins all move from 4.12.0 together. (part of #236)
Screenplay (Release v4.133.0): The canonical screens corpus now records the public CLI 3.43.0 with Stage 4.52.0 vector, the first whose render includes the generated React application on the Stage runtime. Every browser assertion passes, and the render audit passes on all 57 artifacts: they are deterministic and portable, profile rejection publishes nothing, and the rendered application recovers to every declaration in its source. (part of #168) (part of #173)
Chronicle (Release v19.43.0): In ReadModelScenario, a reducer that declares [EventSourceType], [EventStreamType] or [FromEventSource<TSource>(stream)] now receives only the seeded events that match its filter, as it would against a running kernel. A filtered reducer no longer receives events seeded without OnStream unless the default route matches its filter. Seed those events with OnStream on the route the reducer listens to. See Seed routed events
Stage (Release v4.63.2): Stage now gives each reason it refuses a reaction its own code, in the renderer, the Host and the semantic executor. Reactions are still not rendered or run (part of #207).
Stage (Release v4.63.2): STAGE-ESM-024 names the trigger kind: clock (interval or schedule), application trigger, startup, shutdown, or an opaque reaction body.
Stage (Release v4.63.2): The new STAGE-ESM-037 marks a trigger that both produces an event and invokes a command.
Stage (Release v4.63.2): STAGE-ESM-013 names the $context.causedBy.* member a reaction uses.
Stage (Release v4.63.2): Event-triggered reactions report STAGE-ESM-024, saying that reaction rendering is not yet admitted.
Stage (Release v4.63.1): The rendering reference now documents how generated enums are stored. Their numbers follow declaration order, so until Screenplay can give members fixed numbers (https://github.com/Cratis/Screenplay/issues/643), only append new members, and never reorder or remove existing ones.
Stage (Release v4.63.0): Stage now uses Screenplay 4.131.0 and accepts ESM v10 models. Slices that use no v10 construct render and run as before. Each v10 construct is refused with its own code wherever Stage loads a model:
Stage (Release v4.63.0): STAGE-ESM-034: a reaction’s runs as identity.
Stage (Release v4.63.0): STAGE-ESM-035: observer filters, from on reactions and reducers.
Stage (Release v4.63.0): STAGE-ESM-036: route overrides on a single production.
Stage (Release v4.63.0): matches rules now treat $ as the end of the input, as Screenplay 4.130 does. The semantic executor, generated validators and legacy validators all match it, so a value with a trailing newline no longer satisfies a pattern ending in $. (#292)
Chronicle (Release v19.41.0): Registering a pinned reactor or reducer fails when it handles a generation that is not registered for the event type, or two generations of the same event type (part of #4710)
Chronicle (Release v19.41.0): With SQL storage, revising an event now records the revised generation, so pinned consumers receive the revision. Revisions made before this release cannot be told apart from the original content (part of #4710)
Stage (Release v4.62.0): Stage now accepts Screenplay ESM v9 models. Slices that use no v9 construct render, run and specify exactly as they would at v8.
Stage (Release v4.62.0): Each v9 construct is refused with its own code wherever Stage loads a model: the renderer, the Host, the semantic executor, rendered specifications, the legacy renderer, the eventmodel engine and the structural SpecRunner. This includes references from projections, reducers, constraints, reactions, captures, command productions and specifications.
Stage (Release v4.62.0): STAGE-ESM-032: public events, and projections or reducers that target an event.
Stage (Release v4.62.0): STAGE-ESM-033: events that come from another store, and source events captures.
Stage (Release v4.62.0): STAGE-ESM-024: Translate slices, with or without a direction. This is unchanged. (#290)
Arc (Release v22.66.0): Arc depends on Cratis.Fundamentals 7.23.0. (part of #3128)
Chronicle (Release v19.40.0): Testing scenarios share one in-memory event store per scenario. The event log and any named event sequence you append to see the same data, and kernel services that used to throw NotSupportedException in a scenario now answer from that store. For example, the admin password status now reports that no admin password is required (#3434)
Chronicle (Release v19.40.0): An event appended in an older generation is migrated through your registered event type migrations (EventTypeMigration<TUpgrade, TPrevious>) and stored in every generation, in EventScenario as well as in the events you seed into ReadModelScenario. Read models and reducers now see the migrated values (part of #3941)
Chronicle (Release v19.40.0): EventStoreForTesting enforces closes-stream constraints, as EventScenario already did
Chronicle (Release v19.40.0): Concurrent appends to one event sequence in a scenario run one at a time, the way the kernel processes them. Two concurrent appends of the same [Unique] value can no longer both succeed
Chronicle (Release v19.40.0): An event type or generation your scenario did not discover still fails with EventSchemaNotDiscovered. A constraint type the kernel does not know now fails explicitly instead of being ignored
Stage (Release v4.61.0): Whole-number properties, command inputs, events, read models, concepts, stream ids, sentinels and literals render as long for models at ESM v8 and later. Generated TypeScript stays number. (#263)
Screenplay (Release v4.131.0): semantic-diff reloads both sides on every page, so a continuation after either side changed is refused as stale. beforeWorkspaceJson and afterWorkspaceJson keep working; combining one with the matching source object is refused (#558)
cli (Release v3.46.1): The CLI uses Screenplay 4.130.0 (#311)
cli (Release v3.45.0): The ownership manifest .cratis-render.json stores the semantic ids of each managed file and uses schema 2. A destination rendered by an earlier CLI is upgraded on its next render (--check reports that one manifest rewrite with exit 6), and an earlier CLI refuses to publish over a schema 2 destination. Generated files are unchanged (#246)
Screenplay (Release v4.130.0): The Screenplay MCP server accepts a model root that does not exist yet, as long as its parent folder exists. Reading tools treat it as an empty model and create nothing; the folder and its .screenplay state are created by the first apply or recovery write. Hosts such as cratis screenplay mcp --project-root no longer have to create an empty model folder just to start the server (#633)
Screenplay (Release v4.130.0): When the server discovers its root from the client’s project or falls back to Documents/Screenplay, it no longer creates that folder on open; it is created on the first write (#633)
AI (Release v7.27.1): The cratis/codescene profile docs now state that neither the Cratis CLI nor any harness registers the CodeScene MCP server: each user registers cs-mcp (or npx -y @codescene/codehealth-mcp) in their own user-level MCP configuration, never in committed project files (#589)
Stage (Release v4.58.0): Stage and the applications it renders now use Chronicle 19.39.1 and Arc 22.65.3. In this release Chronicle registers event source definitions in the application’s services, which routed commands need when they run.
AI (Release v7.27.0): Pi rule delivery now honours cratis/<profile>-scoped rules: in a repository with .cratis/ai.json, such a rule loads only when it selects that profile or one nested under it. application and framework rules behave as before
Ante (Release v1.3.0): The shell is served by Ante itself for /, /index.html and every application route, with Cache-Control: no-cache, instead of the static file middleware’s default-files handling.
Scene (Release v4.17.0): The Cratis Components toolbar button runs its attached interactions and opens its authored destination - a dialog or a slice screen - through the enclosing navigation host, or announces it with cratis.scene.navigate outside one. (part of #74)
Scene (Release v4.17.0): The business pattern coverage matrix now states its prioritized decisions and the specifications that hold each one. See Business pattern coverage. (part of #73)
Scene (Release v4.16.0): The core action component resolves its argument mapping when it is invoked and adds the values as arguments to the cratis.scene.command event, so a host submits what the user typed. (part of #69)
Scene (Release v4.16.0): A property that declares acceptedBindingKinds accepts a binding expression of one of those kinds in place of its own value type, and refuses other kinds with the accepted ones named. A command form’s inputs can now be bound to a table’s selectedItem. (part of #69)
Scene (Release v4.16.0): The Generate fields action on a command form is disabled, and refuses to run, when the form’s fields come from a binding, not only when they are authored. (part of #71)
Scene (Release v4.16.0): The Cratis.Components manifest no longer declares commandFields and fieldWidths as its own property editors. They are host editor kinds, so design-time hosts no longer report them as missing. (part of #70)
cli (Release v3.43.0): cratis chronicle login no longer accepts a root certificate (PEM or DER) as certificatePath; the setting names a client certificate, as it already did for every other command (#198)
AI (Release v7.24.0): Across the Screenplay skills, description holds a one-line summary with short status markers such as NOT enforced in the model today, and reasoning, assumptions and rejected alternatives go in documentation. (#538)
AI (Release v7.24.0): The model-first opt-in reference names the same model root as the corpus rules: where the project’s .play files live, else Source/ or src/, else Screenplay/. (#510)
AI (Release v7.24.0): The Stage skill states the Arc and Chronicle versions Stage 4.51.3 renders, and separates the protected-decision API from protection Stage emits. (#530)
Arc (Release v22.65.2): Arc depends on Cratis.Screenplay 4.128.0 and @cratis/screenplay-language 4.128.0. (#3134)
Chronicle (Release v19.38.2): Register a new generation only after every Chronicle server in a cluster has been upgraded to this release. A server on an older release can still overwrite stored content during the upgrade. See the migration guide (part of #4189)
Screenplay (Release v4.129.0): A single explicit key decides a read model’s identifier instead of inference from its queries, and binds to the same executable bytes as the inferred identifier. Composite keys and query by blocks are checked when compiling, and executable binding refuses them with PLAY0268 until https://github.com/Cratis/Screenplay/issues/599 admits them (#459)
Screenplay (Release v4.129.0): The identifier-type check for a command route skips productions that carry their own route, and specification route expectations use each production’s effective route (part of #302)
AI (Release v7.23.0): The standalone Screenplay pin moves to 4.127.0; the cratis CLI stays at 3.41.0, and the skills say where its bundled Screenplay 4.114.0 differs.
cli (Release v3.42.0): The CLI bundles Screenplay 4.127.0 and reads executable models up to ESM v9; validate and the Screenplay MCP server admit v9 models (#302)
cli (Release v3.42.0): cratis render refuses ESM v9 models with CLI-RENDER-004 until Stage can render public events (#302)
Screenplay (Release v4.128.0): The canonical screens corpus now records the public CLI 3.41.0 with Stage 4.51.3 vector. Every browser assertion passes, and the render audit passes in full: renders are deterministic and portable, a UI profile naming an unknown package or a missing layout is refused with nothing published, and the rendered application recovers to the declarations its source makes. (part of #168) (part of #173)
Screenplay (Release v4.128.0): The render audit no longer counts the file source reference a recovered read model carries as a member when it compares a recovered model with its source. (part of #168)
Screenplay (Release v4.128.0): The screens release acceptance matrix now reflects this vector and the latest Scene, Stage, Studio, Screenplay and AI deliveries. See Screens release acceptance. (part of #168) (part of #173)
Stage (Release v4.56.0): Stage builds against Cratis.Screenplay and Cratis.Screenplay.CanonicalCorpus 4.122.0. Models that use ESM v9 constructs (public events, event origin, translation direction, event-target projections and reducers, events-source captures) are refused with STAGE-ESM-016 and plan no artifacts. (part of #236) (part of #237)
Stage (Release v4.56.0): A navigate route or parameter is no longer refused with STAGE-SCENE-UI-001. An outlet on a dialog template still is, because a Scene dialog template declares no outlets. (part of #236) (part of #237)
Orleans (Release v1.16.0): Job grains use resource-optimized placement (CPU, memory and activation count) among the silos that host the job type. Cratis/StudioIssues#345
AI (Release v7.22.0): Version pins move to standalone Screenplay 4.125.0 and cratis CLI 3.41.0, which bundles Screenplay 4.114.0, Stage 4.51.3 and Cratis.Arc.Screenplay 22.54.0. (#528)
AI (Release v7.22.0): Event sources, streams and routes are described as binding and running in the reference evaluator (ESM v8); cratis render refuses models above ESM v7 with CLI-RENDER-004, and Stage refuses generated values and responses with STAGE-ESM-028/STAGE-ESM-029. (#528)
AI (Release v7.22.0): A reaction that declares runs as system role with a role the gate admits is a trusted path, not a review defect. (#532)
AI (Release v7.22.0): Discovery describes authored board order instead of name-sorted slices, description no longer has to be the first body line, @pii on an identifier is the PLAY0515 error, and skills that point to the Invoicing sample name its preview-construct exceptions. (#532)
Arc (Release v22.65.0): A routed command states its route instead of the legacy concurrency block. An information diagnostic names each concurrency dimension that is dropped. (#3090)
Arc (Release v22.65.0): Setting ScreenplayOptions.MaximumExecutableModelVersion below v8 keeps the previous output, with routes left out and reported. (#3090)
Arc (Release v22.65.0): Arc depends on Cratis.Screenplay 4.124.1 and @cratis/screenplay-language 4.124.1. Generated documents use the current compliance keywords: pii for personal data and secret for operational secrets. (#3090)
Arc (Release v22.65.0): When the generator leaves out a read model, it also leaves out the queries, screen data, productions and scenarios that depend on it, and says so, so the document still binds. A slice that becomes empty this way is reported. (#3090)
Screenplay (Release v4.127.0): The MCP semantic-diff view and revision comparison now use the same comparison as the library API; their output is unchanged (#555)
AI (Release v7.21.0): The AuthorId examples in the concepts and vertical-slices rules use IGeneratable<AuthorId> with GenerateValue.Uuid() instead of Guid.NewGuid(). (part of #576)
Stage (Release v4.54.0): A command whose stream id cannot be formatted is rejected as a contract failure after its authorization and validation have run, without echoing the value. Specification runs that use routed fixtures are still refused with STAGE-ESM-030. The eventmodel engine and the structural SpecRunner keep refusing routes.
Screenplay (Release v4.125.0): Binding no longer refuses runs as with PLAY0268, and MCP readiness no longer lists it as unsupported
Screenplay (Release v4.125.0): The TimeTracking sample grants its approved-week automation a dedicated PayrollAutomation role as the alternative to the Finance department claim, which human payroll callers still need
Fundamentals (Release v7.23.0): CorrelationId implements IGeneratable<CorrelationId>, and CorrelationId.New() uses GenerateValue.Uuid() (part of #1176)
Stage (Release v4.53.0): Stage and the applications it renders now use Chronicle 19.37.8: the Chronicle client packages, the Host’s bundled cratis/chronicle:19.37.8-development kernel, and the scaffold’s pinned client packages and development image. This release keeps the event source on batch appends, formats event source ids the same way in every culture, and ships the routing conformance that event-source routing builds on. (part of #177)
Scene (Release v4.15.0): A RenderBindingScopeProvider rendered inside another now nests its data context, query results and component outputs over the inherited scope; previously it ignored them. (part of #69)
Scene (Release v4.15.0): Binding paths read only own properties and array indexes, so inherited members such as constructor and length resolve as absent, and a literal binding with a null value counts as absent, matching the C# engine. (part of #69)
Scene (Release v4.15.0): A package host is blocked with a diagnostic when the UI profile names a layout or theme no approved package provides, or a theme incompatible with the profile’s packages. (part of #75)
Scene (Release v4.15.0): With network assets forbidden, a host now blocks any absolute URL other than data: and blob:, and protocol-relative //host/... references, not only http and https. The diagnostic names the assets. (part of #75)
Screenplay (Release v4.124.0): PLAY0557 no longer fires when the reaction declares runs as, and its message now names runs as system role as the remedy. The reaction documentation is corrected: Arc runs a reactor’s commands as the system only when the reactor carries [ExecuteCommandsAsSystem] (part of #383)
AI (Release v7.20.0): Screenplay screen authoring, UI composition, render and Stage guidance now name the public vector that passes the browser acceptance run (CLI 3.40.7 with cratis/stage:4.51.1 and bundled Screenplay 4.114.0) and the latest packages (Scene 4.14.0, Screenplay 4.122.0, Stage 4.51.3, Studio 0.141). (part of #536)
AI (Release v7.20.0): Screen guidance no longer warns about Studio deploy failures or older-vector gaps that pass on the public vector; it keeps the fail-closed guarded Close and double-click refusals (STAGE-SCENE-ACTION-001, STAGE-SCENE-INTERACTION-001), the pending UI-profile and render-recovery work in Cratis/cli#301, and the pending Studio production proof. (part of #536)
cli (Release v3.41.0): A profile naming an unknown package or a missing layout used to publish every artifact and exit 0. It now fails. Fix the profile if a render that used to succeed now reports CLI-RENDER-007 through CLI-RENDER-010. (part of #284)
cli (Release v3.41.0): CLI0017 now names the reason a source path was refused and, when one path is responsible, that path, relative to the solution or project you read.
cli (Release v3.41.0): The bundled Arc source adapter is now 22.54.0.
cli (Release v3.41.0): The CLI now uses Stage 4.51.3, and cratis run starts cratis/stage:4.51.3 by default.
Stage (Release v4.52.0): Generated applications pin their frontend packages to the versions the Stage frontend builds with: @cratis/arc 22.58.2, @cratis/components 4.26.2, @cratis/fundamentals 7.22.8 and @cratis/scene.* 4.12.0. Re-rendering an existing application updates its package.json to these versions. (part of #236)
Stage (Release v4.52.0): A generated application loads the PrimeIcons font, applies the Stage theme and serves styled PrimeReact components. It reads the PrimeUI license from PRIMEUI_LICENSE or STAGE_PRIMEUI_LICENSE at build time. (part of #236)
Chronicle (Release v19.38.0): Cratis.Screenplay is updated from 4.16.0 to 4.111.0. Projection declarations that use syntax Chronicle cannot lower, such as refusal, list or object expressions, now fail with a compiler error instead of an exception (#4118)
Chronicle (Release v19.38.0): The WaitForRegistration documentation now states what a successful registration guarantees: the kernel has registered the artifacts and subscribed their observers. To read your own writes from a materialized read model, wait for the append with WaitForCompletion, or use a passive read model (#4202)
Screenplay (Release v4.123.0): Records browser-native-controls-runtime-3.40.7-4.51.1: CLI 3.40.7 (public Homebrew formula) + cratis/stage:4.51.1 (the CLI’s default) + bundled Screenplay 4.114.0. 51 browser assertions passed, none blocked or pending — the first exact public-release combination where the browser acceptance harness fully passes. Stage #286 (released as Stage v4.51.1) fixed the AllWorkItems route-resolution regression that blocked every earlier public-vector run.
Screenplay (Release v4.123.0): Updates the MCP typed transcript vector to the CLI 3.40.7 rerun (same shape as the 3.40.4 run it replaces: 9 requests/responses, 37 tools, executableReady true).
Screenplay (Release v4.120.0): A standalone navigate to directive in a screen now prints its route, outlet and parameter lines instead of dropping them. (part of #173)
Stage (Release v4.51.3): When a query or command name matches no endpoint, or several distinct ones, Stage attaches no route instead of guessing. The one exception is an unkeyed collection binding whose query has no endpoint of its own: it reads its read model’s All<ReadModels> route, which answers the same rows; a binding with a by parameter is never widened to the unfiltered collection. The element carries routeStatus (unresolved or ambiguous) and a routeDiagnostic, and /stage/routes lists ambiguous names under diagnostics. See Which route a screen calls. (part of #236) (part of #237)
Stage (Release v4.51.3): /stage/routes keys queries and commands by their own name only; full type names and endpoint display names are no longer included as keys. (part of #236) (part of #237)
cli (Release v3.40.7): The bundled Stage is now 4.51.1, so cratis run starts cratis/stage:4.51.1.
Scene (Release v4.14.0): The PrimeReact text, textarea, password, number, date, dropdown and checkbox components use ariaLabel as the control’s accessible name, and every form field in the default blueprint’s templates is named by its label. (part of #73)
Scene (Release v4.14.0): The default blueprint’s tables now pass their records as rows with an emptyMessage, so they show their data when rendered with PrimeReact. (part of #73)
Stage (Release v4.51.2): The eventmodel Host engine now refuses a model that declares named event sources, streams or event-source routes with STAGE-ESM-030 before it runs anything. The Host reports the model as unsupported and answers /api requests with 501, instead of running the model without its routes.
Stage (Release v4.51.2): Structural SpecRunner runs of a model with named event sources, streams or routes now exit with code 1 and STAGE-ESM-030, and write no results, instead of reporting specifications that ignored the routes. Routes run only on the semantic engine. (#257)
AI (Release v7.19.0): Quota and spend-limit errors (Anthropic enforced_spend_limit_reached and “credit balance is too low”, OpenAI and Azure insufficient_quota and billing_hard_limit_reached, HTTP 402) are no longer retried against the same provider. Pool dispatch and pooled conversations park that provider and resend the same request to the next member with capacity. Ordinary 429 throttling still retries after Retry-After (#423)
AI (Release v7.19.0): When every pool member is exhausted, the failure names each provider tried (#423)
AI (Release v7.19.0): A Claude session that exits normally but ends with a quota-exhausted error result is now reported as failed instead of completed (#423)
Scene (Release v4.13.0): Every built-in layout, screen template and dialog template in @cratis/scene.blueprint.default and @cratis/scene.blueprint.components declares compatibility with Scene ^4.13.0 and its package dependencies, Cratis attribution and the MIT license. The default shell and dashboard credit the Sakai arrangement they follow. (part of #73)
Scene (Release v4.13.0): validateNavigationDestinations now uses the shared navigation diagnostic
Screenplay (Release v4.119.0): The screens release acceptance matrix now includes the CLI 3.40.5 and 3.40.6 browser runs, a regression in the work item list on Stage 4.50.1, the render audit results, Studio 0.139.0, and the access the production Studio automation needs. See Screens release acceptance. (part of #168) (part of #173)
cli (Release v3.40.6): The bundled Stage is now 4.50.1, so cratis run starts cratis/stage:4.50.1.
AI (Release v7.18.0): Language model failures from Anthropic, Z.ai and OpenAI-compatible providers name the vendor, model, HTTP status, vendor error type and code, provider id and Retry-After. They also include the vendor’s response body, capped at 2 KiB with credentials removed. The log entry carries the same fields as structured values. (#346)
Chronicle.Mcp (Release v2.0.0): Breaking: the server now runs in the ReadOnly profile by default and no longer registers stop_job, resume_job or delete_job. To keep using them, set Cratis__Chronicle__Mcp__Profile=Mutation and configure an authorization policy as described in the deployment profiles documentation.
Chronicle.Mcp (Release v2.0.0): In the Mutation profile the server refuses to start when the authorization policy is missing, expired or malformed. That includes wrong-shaped list settings, unknown keys, and a list split across configuration sources. Error messages name the setting, never its value.
cli (Release v3.40.5): The bundled Stage is now 4.50.0, so cratis run starts cratis/stage:4.50.0 and cratis render serves by-parameter collection queries filtered by their argument.
Components (Release v4.26.3): Horizontal CommandStepper and StepperCommandDialog now show each step name below its step number, with names wrapping instead of being cut off, so every step stays readable in narrow dialogs (#411)
Screenplay (Release v4.118.0): The browser acceptance harness now runs the CLI’s default Stage image instead of a pinned 4.49.2, records the CLI and Stage versions it actually ran, and removes its Stage container afterward. (part of #173)
Screenplay (Release v4.118.0): The browser acceptance harness reaches the work item list through the authored navigation before checking native create, finds a renamed row by its current title, and matches field labels such as “Comment Id”. The full native create, rename and add-comment flow now runs end to end. A --self-test mode checks these helpers, and run-public-acceptance.sh runs it first. (part of #173)
Screenplay (Release v4.118.0): The canonical corpus now pins the AddComment identifier expectation to the authored model: commentId is a client-supplied, non-generated identifier, so a native form must collect it. (part of #168)
Stage (Release v4.50.0): Generated authorization policies are now rendered one file per protected operation, as GeneratedPolicies/StagePolicy_{operation}.cs. Opaque policy bodies and their typed contexts are rendered one file per use site. GeneratedPolicies/Policies.cs, PolicyBodies.cs and TypedContexts/PolicyContext.cs keep their paths, and their content no longer depends on which slices are rendered. Each policy registers itself, and RegisterGenerated applies the registrations in name order.
Screenplay (Release v4.117.0): Specifications that use when capture over an events source report a typed unsupported result in the reference evaluator.
Screenplay (Release v4.117.0): Documentation, the MCP syntax-schema description, the contract golden, the Monaco hover and completion wording and decision 0051 describe the v9 admission. Consumers must reject v9 documents until they support it.
Stage (Release v4.49.11): The Stage surface ledger now records exactly which query shapes render and which are refused with STAGE-ESM-010: snapshot lists and observable optional lookups are refused. It also records that the default Scene composition leaves list queries out.
Chronicle (Release v19.37.3): Typed event source ids over DateTime, DateTimeOffset, DateOnly and TimeOnly are now written in their round-trip formats (for example 2026-10-23T14:15:16.0000000Z for a UTC DateTime) on every culture. Streams written earlier under a date or time identity, or under a decimal, double or float identity on a culture that uses a decimal comma, now have different ids: append to or read from them through the old string id if you still need them
Chronicle (Release v19.37.2): RegisterRequest has a new optional Registrant field. Existing clients keep working; they simply no longer trigger retirement until updated.
Stage (Release v4.49.9): Stage consumes the Screenplay 4.114 command-form and binding ABI for stable component ids, literal bindings, form generation mode, and form layout metadata. (part of #236) (part of #237)
Screenplay (Release v4.116.0): Recorded the exact public CLI 3.40.4 and Stage 4.49.7 browser acceptance rerun as a new partial released vector while preserving earlier Stage 4.49.5 red evidence. (part of #168) (part of #173)
Screenplay (Release v4.116.0): Tightened native dialog submission targeting so the browser harness submits inside the active dialog instead of clicking a background command button. (part of #168) (part of #173)
Screenplay (Release v4.116.0): Updated the MCP released-vector record with the real AI #563 stdio transcript rerun on public CLI 3.40.4. (part of #168) (part of #173)
Ante (Release v1.2.11): When a host reports onboarding outcomes (Ante:HostOutcomeUrl), the invitation, organization setup and self-service registration wizards no longer stop on a “check again / continue” screen once setup has published. They keep showing the spinner while Ante asks the host again every two seconds, and take the person to the application as soon as the host reports success. The manual screen is shown only when the host reports a failure, or has reported nothing after a minute.
cli (Release v3.40.4): cratis render and cratis run now use Stage 4.49.7 and Screenplay 4.113, so generated screen applications use the released rich screen ABI and default to cratis/stage:4.49.7. (part of #284)
Screenplay (Release v4.115.0): Recorded the exact public CLI 3.40.3 and Stage 4.49.5 browser acceptance rerun as a new partial released vector while preserving the older Stage 4.49.2 partial receipt. (part of #168) (part of #173)
Screenplay (Release v4.115.0): Hardened the browser harness to continue after missing native form fields and record form-control descriptors when Stage exposes command controls without fillable inputs. (part of #168) (part of #173)
Screenplay (Release v4.115.0): Captured the remaining Stage 4.49.5 runtime blockers for scoped comments, selected-row query identity, deep links, stale response discard, invalid native submit suppression, native form fields, and theme application. (part of #168) (part of #173)
Stage (Release v4.49.6): Stage now maps the rich Screenplay screen ABI into typed Scene plans, including stable component ids, literal bindings, command-form generation and layout metadata, component presentation and exposed-value metadata, and literal-null preservation. (part of #236) (part of #237)
Stage (Release v4.49.6): Stage now builds against Screenplay 4.113 and Scene Engine 4.12 so generated plans use the current public screen and keyed-query ABI. (part of #236) (part of #237)
AI (Release v7.17.0): Screenplay screen authoring and Stage render guidance now document the current Scene 4.12, Screenplay 4.114, Stage 4.49.5, CLI 3.40.3, and Studio 0.136.4 vector while keeping runtime, Studio deploy, and CLI Screenplay-package pairing caveats separate. (part of #536)
Screenplay (Release v4.114.0): Screen and form documentation now describes the shared literal, stable-id and Scene geometry contracts that Studio, Stage and Conformance should consume instead of guessing syntax. (part of #168) (part of #173)
cli (Release v3.40.3): cratis render and cratis run now use Stage 4.49.5, so generated screen applications run with stable native command-form descriptors and authored command action routes exposed for native command forms. (part of #284)
Screenplay (Release v4.113.0): Expanded the canonical screen browser harness into a two-item acceptance check that records selected-row identity, scoped comment query, stale-response discard, clear-selection, native command payload, projection persistence, dialog/deep-link, and theme/package rendering blockers instead of treating enabled controls as success. (part of #168) (part of #173)
Screenplay (Release v4.113.0): Replaced the Studio production harness blocker stub with real new/import/save/reopen/export/Play operations that run when a Studio URL is provided and report operation-specific blockers otherwise. (part of #168) (part of #173)
Screenplay (Release v4.113.0): Replaced the MCP folder-source blocker stub with a JSON-RPC transcript client for initialize, tool discovery, scratch workspace open, PreserveTrivia proposal, stale revision refusal, dropped-comments check, apply, reopen, and revision-change verification. (part of #168) (part of #173)
Screenplay (Release v4.113.0): Refreshed the released screen vector matrix to keep Stage 4.49.2 partial evidence labeled partial and prepare a Stage 4.49.4 rerun once the compatible CLI release is available. (part of #173)
Chronicle (Release v19.37.0): The capture engine now subscribes events captures to their inbox event sequences per namespace, alongside api sources. (part of #4640)
Screenplay (Release v4.112.0): Decision 0049 is accepted and records the origin as a quoted store name and when PLAY0614 applies.
Screenplay (Release v4.112.0): repair-capabilities now lists five repairable codes, including PLAY0614.
Stage (Release v4.49.3): Stage frontend now consumes the Scene 4.12 command-form geometry contract for generation mode, field placement, row and column spans, gaps, and width constraints, with Scene frontend packages pinned to 4.12.0. (part of #236) (part of #237)
Screenplay (Release v4.111.0): Browser-native controls harness now records released Stage endpoint success, seeded list/detail/comment rendering, selection clearing, theme/menu rendering, and disabled native command blockers. (part of #168) (part of #173)
Screenplay (Release v4.111.0): Released-vector results now move the browser status from missing Stage endpoints to partial browser pass with native command actions pending. (part of #168) (part of #173)
Screenplay (Release v4.111.0): Screenplay interoperability documentation now describes the Stage 4.49.2 browser progress and remaining native action blockers. (part of #168) (part of #173)
Screenplay (Release v4.110.0): Released-vector results now preserve the browser blocker as missing /stage/routes, /stage/scene, and /stage/locales responses instead of treating the running shell as a browser pass. (part of #168) (part of #173)
Screenplay (Release v4.110.0): Screenplay interoperability documentation now names the browser harness and the Stage endpoint blocker for native-control conformance. (part of #168) (part of #173)
Chronicle (Release v19.36.0): Appending a private event type to the outbox is now rejected, and the event log cannot be used as a publication target.
Chronicle (Release v19.36.0): The event type registration contract carries visibility and origin; clients that omit them keep working.
Screenplay (Release v4.109.0): Stage plan expectations now move from backend-only red evidence to authored Scene composition evidence while keeping browser-native controls, Studio production Play, and folder-source MCP revision editing pending. (part of #168) (part of #173)
Screenplay (Release v4.109.0): Screenplay interoperability documentation now describes the authored-render released vector and its remaining guarded/browser/Studio blockers. (part of #168) (part of #173)
Screenplay (Release v4.108.0): Stage plan expectations now preserve the released CLI/Stage red evidence instead of the previous refusal vector. (part of #173)
Screenplay (Release v4.108.0): Screenplay interoperability documentation now records the exact released-vector pass, red, and pending matrix for screen composition conformance. (part of #168) (part of #173)
AI (Release v7.15.0): Stage and render guidance now flags authored UI omissions and silent default composition as unsupported output rather than partial delivery. (part of #536)
cli (Release v3.40.0): cratis render now bundles Stage 4.49.1 with Screenplay 4.105.0, so the canonical screen-composition corpus observable query surface and query-only specifications plan through the released renderer. (part of #284)
cli (Release v3.40.0): cratis run now defaults to the matching cratis/stage:4.49.1 sandbox image instead of the previous Stage 4.43 image. (part of #284)
cli (Release v3.40.0): Screenplay executable validation now follows the bundled 4.105 binding behavior for imported root files and explicit event streams. (part of #284)
Stage (Release v4.49.0): Stage now consumes Screenplay 4.105.0 and the matching canonical corpus release that includes executable observable collection query shapes for the screen-composition corpus. (part of #236)
Stage (Release v4.49.0): The Cratis renderer now admits and emits the screen corpus read-model query surface for no-argument observable collections and by-parameter observable collections, including AllWorkItems and CommentsForWorkItem, while preserving protected event-source route refusals. (part of #237)
Stage (Release v4.49.0): The screen corpus backend surface now preserves command literal mappings, partial projection update events and non-colliding scoped projection implementation names, and now generates executable query-only specifications for the corpus listing, comments and details scenarios. (part of #236) (part of #237)
Screenplay (Release v4.106.0): Screenplay interoperability documentation now distinguishes working-branch evidence from final released-vector execution for the screens corpus. (part of #168) (part of #173)
Stage (Release v4.48.0): Event-source routes from Screenplay 4.101 are refused with STAGE-ESM-030 on every rendering and admission path, including the legacy renderer and specification runs, instead of being dropped. (part of #250)
Stage (Release v4.48.0): Screen navigation routes and parameters and dialog-template outlets are refused with STAGE-SCENE-UI-001 instead of being silently dropped, and a semantic or legacy Stage host reports these scene refusals as unsupported instead of failing at startup. (part of #250)
AI (Release v7.14.5): Questions about API keys and other credentials passed to an Arc command now reach the command skill, which explains [NotAudited] and, for retained secrets, [Encrypted] (#549)
AI (Release v7.14.5): Questions about an observable query that Arc does not discover because it is declared as Subject or BehaviorSubject now reach the read-model skill (#549)
AI (Release v7.14.5): The README explains that Claude Code and Codex limit how many skill descriptions they list, and how to install fewer profiles or raise Claude Code’s budget (#549)
Stage (Release v4.47.0): Stage now consumes Screenplay 4.101.0 and the matching canonical corpus, allowing the published screen-composition corpus to plan its Scene application surface instead of relying on the legacy RegisterProject byte fixture. (part of #236)
Stage (Release v4.47.0): Screen conversion now preserves typed screen-language constructs for generated and live Scene parity: package-backed components, toolbars, icons, presentation values, nested component bindings, component outlets, template metadata and guarded actions. (part of #237)
Stage (Release v4.47.0): Unsupported backend event-source route semantics from the newer Screenplay compiler are explicitly rejected with STAGE-ESM-030 until the Cratis renderer can generate them, preserving protected backend semantic refusals while admitting the screen surface. (part of #236) (part of #237)
Screenplay (Release v4.102.0): CLI/Stage screen parity now preserves the released CLI 3.39.0 and Stage 4.43.0 refusal diagnostics as a red vector instead of substituting the legacy render for screens acceptance. (part of #173)
Screenplay (Release v4.102.0): Screenplay interoperability documentation now distinguishes the real screens corpus contract from the legacy RegisterProject compatibility evidence. (part of #168) (part of #173)
Arc (Release v22.61.0): A concept used as a command identifier, event-source identifier, destination or stream id has its @pii and @sensitive annotations left off, because Screenplay rejects protected identities there; SP0059 (Information) reports it and the identity and route stay in the document (#3079)
Arc (Release v22.61.0): A scenario whose routes conflict with the declared source and stream types is left out with SP0039 instead of emitting a guessed route (#3060)
Arc (Release v22.61.0): Without AuthoringOnlyConstructs, a scenario that needs an event route is left out with SP0060 (Information) rather than dropping the route silently. An unrouted occurrence in authoring-only output is reported with the same code (#3060)
Arc (Release v22.61.0): A command’s source and stream route is left out when one of its productions is routed explicitly or cannot be proven, and the source’s identifier type is not a Uuid, so the document compiles under the stricter checks (#3060)
Screenplay (Release v4.101.0): then events in any order now finds an assignment instead of matching greedily, at v8 only. Specifications at earlier versions keep their outcomes. (part of #407)
Screenplay (Release v4.101.0): Some route mappings are still refused:
Screenplay (Release v4.101.0): A mapping that reads a property path, or a route on a handler command, keeps PLAY0268.
Screenplay (Release v4.101.0): A mapping from a generated property, a stored source or stream name that collides, and a source stored as Default now report PLAY0273.
Screenplay (Release v4.100.0): Personal data is marked with the keyword pii after the concept type (concept Email : String pii); personal is accepted as the same marker. Operational secrets are marked with secret, because “sensitive” reads as GDPR special categories (part of #557)
Screenplay (Release v4.100.0): An unknown compliance marker is an error instead of being ignored (part of #557)
Arc (Release v22.60.0): SP0028 is now reported for each part of a screen that cannot be read, instead of once per screen. A column with a custom body or selection renderer, a column without a field, a computed title or header, a DataPage menu item, a detailsComponent, a table or dialog bound to another slice’s query or command, and a component with spread properties are each left out and reported. A screen using none of the known components still reports it once. (part of #3049)
Stage (Release v4.44.0): The semantic host’s /stage/semantic/admission report lists specifications the run endpoint can execute as supported, instead of reporting every specification as unavailable. (part of #23)
cli (Release v3.39.0): cratis render and cratis run now consume the released Stage 4.43.0 renderer package and default the run container to cratis/stage:4.43.0, carrying the native Arc CommandForm shell era and the shared Scene 4.10 typed-binding contracts. (part of #284)
cli (Release v3.39.0): The bundled Screenplay compiler, MCP server and canonical corpus move to 4.93.0, the release Stage 4.43.0 is compiled against; render planning against the older compiler release failed while loading the renderer. (part of #284)
Screenplay (Release v4.98.0): PLAY0526 now refuses route lines only in command and read-model examples, and its message says so. PLAY0548 no longer fires for a route under when redelivered. (part of #491)
AI (Release v7.14.3): Ten skills that exceeded 500 lines or about 5,000 tokens now keep their decision rules, traps and version pins in SKILL.md and move secondary detail into reference files: the .NET, TypeScript, Elixir and Kotlin Chronicle clients, reactors, Arc commands in TypeScript, and the Screenplay capture, command-surface, event-modeling and specifications skills (#542)
AI (Release v7.14.3): Reference files longer than 100 lines open with a contents list, so an agent that previews the top of a file still sees everything it covers (#542)
AI (Release v7.14.3): Links to reference files say when to read them, and traps an agent must know before acting now sit in SKILL.md ahead of the material that depends on them (#542)
AI (Release v7.14.3): Capability limits are stated against the version each skill was verified on instead of “today” or “yet” (#542)
AI (Release v7.14.3): Screenplay skills name the screenplay MCP server together with each tool they call (#542)
AI (Release v7.14.3): The read-model skill is pinned to Arc 22.16.0 and the performance review to Components 4.26.2, the versions their APIs were verified against (#542)
AI (Release v7.14.3): Six skill descriptions no longer contain generic type brackets such as IProjectionFor<T>, which the Claude Skills API rejects (#542)
Screenplay (Release v4.97.0): The positive typed screen source case parses with zero authoring diagnostics and asserts its typed screen shape: template assignments, toolbar items, component bindings with null-clear behavior, dialog template references and manual form columns. (part of #168) (part of #173)
Screenplay (Release v4.97.0): The MCP authoring harness is executable on the released version vector; only browser, CLI/Stage and Studio harnesses stay pending on their later releases. (part of #168) (part of #173)
Stage (Release v4.43.0): The live Stage command form renders through the native Arc CommandForm: command fields built from the modeled form schema with required-field validation at the field boundary, native server-side validation and exception feedback, automatic layout or manually placed unequal columns, and query refresh after a successful submit. (part of #236)
Stage (Release v4.43.0): Typed bindings resolve through the shared Scene engine resolvers instead of a local path reader, adding nested component property paths, preserve/clear null behavior and mode/value-type diagnostics for synthesized screens. (part of #237)
Stage (Release v4.43.0): The Stage runtime frontend pins exact Scene 4.10.0 with Arc 22.58.2, Components 4.26.2 and Fundamentals 7.22.8, and the .NET renderer contracts pin Scene.Engine and Scene.Model 4.10.0 so the emitted shell and the runtime share the same binding contracts. (part of #237)
Arc (Release v22.58.3): Command scenarios whose only failure assertion is ShouldNotBeAuthorized, ShouldHaveExceptions, or ShouldNotBeSuccessful are no longer generated as rejections, because they do not prove a validation or constraint rejection. They are omitted and reported as unreadable specifications. (#3046)
Stage (Release v4.42.0): Stage now compiles models with Screenplay 4.93.0. Models therefore get that version’s checks: PLAY0504 is an error when a routed command’s identifier type, or an event’s destination type, differs from the target event source’s identifier type, and stream id literals on command and specification routes are validated. (part of #243)
cli (Release v3.38.0): cratis render and cratis run now use Stage 4.40.0 packages and the matching cratis/stage:4.40.0 runtime image by default. (part of #284)
Stage (Release v4.40.0): Live Stage now renders authored dialog templates instead of reporting every dialog as unsupported. (part of #237)
Stage (Release v4.40.0): Stage screen composition now carries template chrome, screen content and authored command forms into the same rendered application surface. (part of #236)
Stage (Release v4.40.0): Stage command forms now use modeled field metadata, command route lookup, validation feedback and query refresh at the submit boundary. (part of #237)
Stage (Release v4.40.0): Stage bindings now accept Scene 4.9 typed component-property paths in addition to the legacy binding path adapter. (part of #237)
Screenplay (Release v4.93.0): PLAY0504 is now an error, not a warning, when a routed command’s identifier type, or an event’s destination type, differs from the identifier type of the event source it routes to. Unrouted commands are unaffected. (part of #407)
Screenplay (Release v4.93.0): Stream id literals on command routes and specification routes are now checked like any stream id. Text must be non-empty, well-formed and in Unicode NFC form. In the default numeric mode, an integer must lie between -9007199254740991 and 9007199254740991. Specification route contradictions compare canonical values, so a UUID written in another case is the same id. (part of #407)
Stage (Release v4.39.0): Live Stage screen rendering now keeps table query state, row selection and binding data scoped to each table instance, including keyboard selection and selection clearing. (part of #237)
Stage (Release v4.39.0): Stage query bindings now support scoped argument rebinding and stale request cancellation before updating rendered data. (part of #237)
Stage (Release v4.39.0): Generated and live Stage frontends render through the Scene 4.9 default blueprint and PrimeReact package composition instead of flattening screen slots. (part of #236)
Screenplay (Release v4.90.0): The commands guide notes that its running-total event example is a counter, not a generic update event (part of #393)
cli (Release v3.37.0): The CLI bundles Stage 4.36.0, and cratis run starts the Stage 4.36.0 container, which compiles models with Screenplay 4.81.5.
cli (Release v3.37.0): cratis render admits ESM v5 to v7 and leaves refusals to the renderer, which names the construct it cannot render: reactions, captures, triggers and Automation or Translate slices (STAGE-ESM-024), read-model absence assertions (STAGE-ESM-027), generated command values (STAGE-ESM-028) and command responses (STAGE-ESM-029). Policy negation now renders. CLI-RENDER-004 is reported only for a model newer than ESM v7.
cli (Release v3.37.0): Rendered policies no longer refuse number or Boolean claim comparisons, which never match, and compare Uuid, Date and DateTime claims only against Screenplay’s canonical text, so generated policy code changes for those claims.
cli (Release v3.37.0): cratis run refuses a screen action with when … execute alternatives (STAGE-SCENE-ACTION-001).
cli (Release v3.36.0): The bundled Screenplay compiler and MCP server are now 4.87.0, which adds the propose-source authoring tool to cratis screenplay mcp; the MCP reference lists it (#285)
Screenplay (Release v4.89.0): When a proposal is refused because an identity migration is missing or stale, the refusal names each address and which argument it belongs in (semanticRenames, eventRenames, retiredSemanticAddresses or retiredEventAddresses), and MCP returns them as identityMigrationIssues (part of #386)
Screenplay (Release v4.89.0): The TypeScript compiler, VS Code and Monaco report the guarded screen action diagnostics PLAY0345 to PLAY0348, matching the C# compiler (part of #527)
Screenplay (Release v4.88.0): PLAY0515 now also refuses a @pii or @sensitive concept used as a stream id type, as a composite stream id part, or as the source of a route’s stream id mapping. Before, it only covered identifiers and event source destinations. The message suggests a surrogate identifier and never shows the value. (#525)
AI (Release v7.14.2): A secret concept that the system keeps, such as a third-party API key, now takes Chronicle’s [Encrypted] together with Arc’s [NotAudited]; personal data keeps [PII] alone, never combined with [Encrypted], and neither marking belongs on an event source id (#531)
AI (Release v7.14.2): Credentials used for authentication are described as never stored: a password or token given to a command is [NotAudited], and events carry only a hash or a reference. The security review skill and both security-reviewer agents now agree on this (#531)
AI (Release v7.14.2): Screenplay’s @sensitive is described as an operational secret, rendered as [Encrypted] plus [NotAudited], with the Screenplay versions that reject @pii (4.69.1) and @sensitive (4.84.1) on identifiers (#531)
Stage (Release v4.36.1): Stage builds against Screenplay 4.84.1. (#201)
Screenplay (Release v4.84.1): @sensitive now means an operational secret, not personal data: encrypted at rest without erasure and withheld from the causation chain. C# providers render it as [Encrypted] and [NotAudited], and @pii @sensitive as [PII] only. The concepts guide, diagnostics reference and editor hovers describe this mapping, and decision record 0034 records it (#384)
cli (Release v3.35.0): The cratis screenplay validate JSON summary reports valid, errors and warnings, and with --check it also reports checks, completenessStatus and, when the checks were skipped, completenessNote.
Stage (Release v4.34.0): A screen action with when … execute alternatives (a guarded action, Screenplay 4.81) is refused with STAGE-SCENE-ACTION-001 instead of being rendered, because the Scene components Stage renders to cannot yet pick a command from the selected item’s state. Screens without guarded actions are unaffected. (part of #209)
Arc (Release v22.58.0): A command or append scenario whose facts set off a reactor that is now declarative is left out and reported with SP0039, because Arc’s scenarios do not run reactors while the generated specification would include the reaction’s facts. (#3040)
Screenplay (Release v4.82.3): The samples policy names the preview constructs that stay out of the Invoicing sample while the executable model refuses them, each with its issue and fixture, and a specification fails when a language construct is neither in Invoicing, a preview construct, nor covered by another named sample (part of #495)
cli (Release v3.34.0): The CLI bundles Screenplay 4.81.7 and Stage 4.30.0.
cli (Release v3.34.0): cratis screenplay validate reports new diagnostics for depends on: PLAY0554 and PLAY0555 (warnings) for an invalid or repeated target, PLAY0552 (warning) for a dependency the model uses but the container does not declare, and PLAY0553 and PLAY0556 (information) for an unused or mutual declaration. Warnings fail --warnings-as-errors.
cli (Release v3.34.0): cratis screenplay validate and cratis render reject a personal-data value typed directly in a reaction trigger as a reaction destination (PLAY0515), report PLAY0524 once per missing required fixture property and PLAY0519 for a property assigned twice in a step, and resolve a reaction’s for to the event when an event and an application trigger share a name.
cli (Release v3.34.0): Printed models keep large integers and small fractions as written instead of in scientific notation.
cli (Release v3.34.0): cratis render produces applications for Arc 22.50.5 and Chronicle 19.32.0, renders role-only and claim-only policies as Arc policies, and refuses a specification whose caller is not signed in but has roles or claims (STAGE-ESM-011).
cli (Release v3.34.0): cratis run starts the Stage 4.30.0 container. It still compiles models with the container’s own Screenplay release, which does not parse policy negation, depends on, example, conditional screen actions or specification event routes, so a model that uses them can pass cratis screenplay validate and still fail cratis run.
Stage (Release v4.33.0): Stage builds against Screenplay 4.81.5 and admits models of executable model versions 5 to 7. A model that uses a construct Stage does not render yet is refused, for the slices being rendered, with a diagnostic naming that construct: STAGE-ESM-024 for reactions, captures, triggers and Automation or Translate slices, STAGE-ESM-027 for read-model absence assertions in specifications, STAGE-ESM-028 for generated command values and STAGE-ESM-029 for command responses. Models that use none of them render as before. (#201) (#206)
Stage (Release v4.33.0): The semantic runtime refuses the same constructs instead of running models it cannot execute. (#201)
Screenplay (Release v4.82.0): The timeline-order check now also covers reducers and reads. A reducer’s on rules count like projection events, and a command or reaction that reads a read model built by a slice drawn after it is reported as PLAY0516, naming the read model. Reading a view that is built from facts produced on the reader’s own side is a feedback loop and is not reported. PLAY0517 now says that its members depend on each other’s events or read models. The typed repair covers the new findings. (part of #413)
Stage (Release v4.31.0): Policies that compare a claim with a number or a Boolean are no longer refused. As in Screenplay, such a comparison never matches, so the rest of the policy decides: an or with a role still allows callers with that role, and the comparison alone denies. (part of #57)
cli (Release v3.33.0): cratis screenplay mcp --help uses the same help layout as every other command and writes it to standard output; protocol runs still keep standard output for JSON-RPC and start no update checks. cratis screenplay mcp now rejects a blank --project-root or --project-root-env value.
cli (Release v3.33.0): cratis screenplay mcp install|status|update|uninstall is deprecated and runs the matching cratis screenplay desktop command after a notice on standard error.
cli (Release v3.33.0): cratis new --help describes the reserved list template value and the wizard.
Stage (Release v4.30.0): The semantic runtime builds its scene from the Screenplay semantic model instead of the legacy event model; authored screens and layouts are still read from the model’s syntax. (part of #23)
Stage (Release v4.29.0): A concept marked @sensitive renders as [Encrypted] and [NotAudited]: its values are encrypted at rest and kept out of the causation chain, but not enrolled in erasure as personal data. It previously rendered as [PII]. A concept marked both @pii and @sensitive renders as [PII] only. (#197)
Stage (Release v4.28.0): Stage refuses to render a model whose @pii or @sensitive concept is used as an event-source identity (a command identifier, a projection key or a for destination), with STAGE-CRATIS-COMPLIANCE-001, before writing any output. Chronicle does not allow personal data as an event source id. @pii on other concepts still renders as [PII]. (part of #197)
Stage (Release v4.28.0): The “Rendering N application(s)” message is printed after the model has been read, and is not printed when the event model is invalid. (#187)
Stage (Release v4.27.0): Specifications whose caller is not signed in but carries roles or claims are refused with STAGE-ESM-011, because Arc removes roles and claims from callers who are not signed in. (part of #57)
Stage (Release v4.26.0): Stage translates tenants the same way in its own runtime, in generated command handlers and in generated reducers: the default tenant, and an Arc request with no tenant, become the zero-GUID portable default (TenantId.Default). A named tenant keeps its exact name, and a tenant named as an empty string or as the zero GUID is refused rather than merged into the default. Generated command handlers previously wrote Arc’s raw Default value. (#185)
Screenplay.CritterStack (Release v0.25.0): Dependencies are updated and generation is verified against Screenplay 4.47.0 and Screenplay Generation 0.18.0
Stage (Release v4.25.0): Rendered applications build against Arc 22.50.5 and the Chronicle 19.32.0 client and development image, the versions Stage itself runs. The frontend moves to @cratis/arc 22.50.5 and @cratis/fundamentals 7.19.8. (#216)
Stage (Release v4.25.0): Rendered backend projects turn off Arc’s embedded Screenplay extraction (CratisEmbeddedScreenplayEnabled=false), because the .play model they were rendered from is already the source of truth. (#216)
Arc (Release v22.55.1): Arc uses Cratis.Screenplay 4.80.0, and the embedded board uses the 4.80 language package. Generated documents still compile cleanly and bind. The embedded board shows only compiler warnings as warnings, not the new timeline-order notes. (#3066)
Components (Release v4.26.2): The SchemaEditor tree layout now offers concepts in a Concepts submenu of the type menu, instead of listing them inline, so the menu stays short when a domain has many concepts. When none are defined the submenu shows the existing “no concepts” hint.
cli (Release v3.32.0): cratis screenplay validate states which verdict it checked: the JSON summary reports checked (source or executable), and the text summary says that a plain pass checks the source only. The Screenplay reference explains the difference between a valid, an executable and a renderable model.
cli (Release v3.31.0): cratis screenplay generate uses Cratis.Arc.Screenplay 22.52.0. Generated Arc models now carry command identifiers, for routing, inline events, event metadata, named rules and when append specifications. Generated identifiers and command responses produce ESM v7 models, which cratis render does not accept yet. (#262)
AI (Release v7.14.1): The Arc command rules and skills now say a command Handle() never returns a nullable event or null to mean “nothing to do”. Missing state or a failed rule rejects the command with Result<TEvent, ValidationResult> and ValidationResult.Error(...), a validator, or Provide(). The ARC0006 guidance says to handle a missing read model by rejecting. Optional command operations are unaffected. (#518)
AI (Release v7.14.0): IProviderChatClientFactory.Create is asynchronous, so an application that keeps provider credentials protected can reveal one (a call to a key service) before the vendor client is opened. Applications register their own factory; the default one is unchanged in behavior.
Screenplay (Release v4.76.1): The VS Code extension turns off word-based suggestions for .play files, so suggestions come from the language service alone.
cli (Release v3.30.0): The CLI bundles Screenplay 4.74.0, whose compiler and embedded MCP server read executable semantic model (ESM) v7: generated command values and command responses.
cli (Release v3.30.0): cratis screenplay validate and cratis render reject a @pii concept used as an event-source identifier, a command identifier or a command or reaction for destination (PLAY0515, an error; use a surrogate identifier). Models that validated before can fail.
cli (Release v3.30.0): cratis screenplay validate warns about undeclared events in projection removals and capture appends (PLAY0166) and about projection mappings to read-model properties that are not declared (PLAY0514); these warnings fail --warnings-as-errors.
cli (Release v3.30.0): cratis screenplay validate reports two information diagnostics, which never fail validation: PLAY0516 for a slice that uses an event from a slice drawn after it, and PLAY0517 for slices, features or modules that use each other’s events.
cli (Release v3.30.0): Validating a root file merges its imported files depth-first in import order, where it was breadth-first before. When parts of one module or feature are imported at different depths, this can change which of two conflicting declarations is kept and reported first.
cli (Release v3.30.0): With no arguments and no .cratis/ai.json, cratis screenplay mcp now serves the model folder inside the single root the client offers rather than the root itself. It keeps the folder nearest that root which already holds .screenplay state, and otherwise uses the common folder of its .play files, else Source or src, else a new Screenplay folder it creates. It reports competing folders that hold state, and an interrupted write in one of them blocks the workspace until that folder is opened and recovered. With neither a client root nor a model in the current directory it creates and serves Documents/Screenplay, where it previously asked for a path.
cli (Release v3.30.0): The embedded MCP server merges workspace files in file-path order. Its expand-layout tool writes import-based files, with one file per slice for the slice layout, and refuses a layout that would change the authored order. read-workspace view=repairs and propose-repair offer a repair for PLAY0516, and the new dependency-graph tool shows how slices, features and modules depend on each other.
cli (Release v3.30.0): When the embedded MCP server rewrites module and feature files it keeps their import lines where they were written, and its execution readiness names command handlers and exact numbers for any model that uses them.
cli (Release v3.30.0): The visualize-model event model board is drawn in authored declaration and import order, shows each specification’s command once with its values, error messages and caller, and counts reactions in its added and removed summaries.
Screenplay (Release v4.75.0): The VS Code extension turns GitHub Copilot inline suggestions off for .play files by default. Re-enable them with "github.copilot.enable": { "screenplay": true }.
Arc (Release v22.52.0): Arc uses Cratis.Screenplay 4.68.2. (part of #2887)
Arc (Release v22.52.0): Commands whose handler is empty or only returns a response no longer get a handler file reference, and SP0044 is reported as information when AuthoringOnlyConstructs is off. (part of #2887)
AI (Release v7.12.0): Rate-limit recording moved into the shared ProviderRateLimitRecorder, used by both completions and chat clients.
Screenplay (Release v4.73.2): expand-layout refuses to propose a layout that would change the authored order of modules, features or slices. It now takes that order from the same root the compiler’s timeline check uses, so an import-less application.play beside a single importing file no longer leads to path order. When there is no root to take the order from, the proposal’s review text says that path order was used. (#412)
Components (Release v4.26.1): The SchemaEditor tree layout now shows each property type as a colored chip, matching how types look on the event model board, and names a concept in a highlighted chip. The type menu uses the same chips, a deeper shadow and roomier items, and rows pick up a primary-colored border on hover.
Components (Release v4.26.1): The chip colors are --cratis-schema-editor-type-* and --cratis-schema-editor-concept-* custom properties, so an application can retheme them.
Screenplay (Release v4.72.0): expand-layout writes import barrels instead of repeating module and feature headers in every file: application.play imports module files; with layout: "feature" or "slice" a module file imports its feature files, which import nested features and, for "slice", one file per slice holding only that slice, while layout: "module" keeps features and slices inline in the module file. Parameters and destination paths are unchanged, and authored order, comments and identities are preserved. (#434)
Screenplay (Release v4.72.0): Compiling from a single root file now merges imported files depth-first in import order, where it was breadth-first before. Wildcard matches stay alphabetical and folder compilation keeps file-path order. This can change merged sibling order, and which of two conflicting declarations is kept and reported first, when parts of one module or feature are imported at different depths. Applies to the .NET compiler, the standalone tool and the TypeScript compiler and VS Code extension. (#434)
Screenplay (Release v4.72.0): Canonical printing keeps import lines in module and feature files where they were written instead of moving them directly after the description, so the timeline-order repair for imports that follow declarations (PLAY0516) is now offered. (#434)
Chronicle.Go (Release v0.9.0): Sequence.Revise accepts replacements with PII or subject, namespace or global encryption instead of returning ErrUnsupported. The kernel protects the revision and its system request with the original event’s subject, and erasing that subject removes the revised personal data. Revising with an unclassified generation of an event type that another generation classifies is still refused, because that plaintext could not be erased. (part of #87) (part of #40)
Chronicle.Go (Release v0.9.0): Classified read models work on projection replay routes: bounded and passive GetAll, ReplayProjection, GetSnapshots, hydration sessions and immediate projections release each value with the subject it was written under, for both Id and id keys, instead of returning ErrUnsupported. (part of #87) (part of #33)
Chronicle.Go (Release v0.9.0): Decision reads admit classified models, as in C#, and server agreement no longer compares server-side protection metadata. (part of #87) (part of #34)
Chronicle.Go (Release v0.9.0): Projections that subscribe to all events and also map explicit event types can be read through bounded collection replay, ReplayProjection and GetSnapshots. (part of #87) (part of #33)
Chronicle.Go (Release v0.9.0): Protection declared beneath an unprotected map, and on array elements that are themselves lists or maps, now registers instead of failing with declarations.DeclarationError. Beneath a map, the kernel protects each map value’s classified members; a classified list- or map-valued array element is protected and erased as a whole element. (part of #87) (part of #35)
Screenplay (Release v4.69.0): The C# compiler now computes the authored order of a folder model from the same root the boards use: the single root, otherwise an application.play that imports something, otherwise the only importing document. Order stays out of the executable model, its revisions and identities. (part of #413)
Chronicle.Go (Release v0.8.0): Compiling a projection now fails with a located declaration error when a derived children collection has no or several registered derivatives, when its discriminator cannot be written as a kernel literal, when a global mapping targets _derivedTypeId, or when a derivative declares projection mappings outside a children collection of its family, including nested interface fields. The C# client instead writes children without a discriminator or drops those declarations.
AI (Release v7.11.5): Require session prompts and handovers to state their repository, branch, expected HEAD, named worktrees and date, and verify those preconditions before continuing; mismatches mean the prompt is stale, not that work is lost (#403)
AI (Release v7.11.5): Make plain method calls the default specifications for pure command, reducer and reactor decisions, adding scenarios where pipelines, validation, constraints or projections contribute proof; distinguish application-assembly Debug wrappers from dedicated spec projects and allow message assertions when exact wording is specified behavior (#449)
Chronicle (Release v19.32.5): The compliance documentation describes what erased [PII] values release as for each schema type: empty strings, 0 or false for non-nullable numbers and booleans, and null for nullable values. See Erasing a subject. (part of #4620)
Chronicle (Release v19.32.5): The key lifecycle documentation explains how stored-event migration and event revision release protected values strictly. Operational failures abort the write. Migration stores erased values for an erased subject, while a revision still needs an authorized new key. A data key that cannot be unwrapped for a subject with a recorded erasure is treated as erased. See Key lifecycle. (part of #4619)
Chronicle.Go (Release v0.7.0): Generated contracts are pinned to Chronicle 19.32.3 (contracts.ProtocolVersion), and the getting-started and contributing guides start cratis/chronicle:19.32.3-development.
Chronicle.Go (Release v0.7.0): Decision guards are qualified on Chronicle 19.32.3. Upgrade the kernel to 19.32.3 before using decision reads; other kernel versions, including 19.29.4, return chronicle.ErrUnsupported. (#79)
Chronicle.Go (Release v0.7.0): Webhook Bearer, Basic and OAuth authorization is persisted in the selected event store on Chronicle 19.32.3, and the documentation no longer lists the missing authorization as a kernel limitation. (#48)
Chronicle.Go (Release v0.7.0): Global confidentiality (encrypted(scope=global)) and protected numeric scalars are documented as working from Chronicle 19.32.3. (part of #35)
Chronicle.Go (Release v0.7.0): RemovedWithJoin removes children identified by id or Id on Chronicle 19.32.3. (part of #26)
Chronicle.Go (Release v0.7.0): Projection queries without an explicit read-model target infer their schema on Chronicle 19.32.3. (part of #27)
Chronicle.Go (Release v0.7.0): The reactor guide no longer requires waiting for observers before the first append on Chronicle 19.32.3; the wait remains documented for older kernels.
AI (Release v7.11.4): The Screenplay skills describe ESM v7 from Screenplay 4.68.0: generated command values and command responses bind and run in the standalone compiler, with fixtures for generated values and then returns for declared responses, while the cratis CLI’s bundled 4.66.0 still refuses them and Stage does not render them, so they are gap-fill (#515)
AI (Release v7.11.4): Features that no ESM version admits yet (exact numbers, operations, event sources and streams, reads) are named by feature instead of by a planned version number, following Screenplay’s admission-time numbering (#515)
Screenplay (Release v4.68.0): MCP execution readiness now names command handlers and exact numbers for any model that uses them, and reports generated properties on concepts with validation rules as not executable. (part of #309)
Chronicle (Release v19.32.3): Upgrade every kernel silo in a cluster together rather than one at a time. While silos run different versions, an observer that finishes catching up may not be notified and may deliver some events again once it is recovered.
Chronicle.Go (Release v0.6.0): Binary values are refused with ErrUnsupported before registration in every other use. That includes collections of binary values, which the pinned kernel corrupts when projecting them (Cratis/Chronicle#4595). It also includes maps, joins, variants, keys, identities, subjects, indexes, unique constraints, protection, event migrations and literals. Types that contain binary values must use simple ASCII property names that are unique regardless of case and are not reserved by the kernel (part of #64)
Chronicle.Go (Release v0.6.0): Decoding a binary value accepts only canonical, padded base64. Values with whitespace or null elements, which the C# client tolerates, are rejected (part of #64)
AI (Release v7.11.3): The Stage and Screenplay skills describe Stage 4.24.2: ESM v4 models render when every event they use is at its first revision, an evolved event is refused with STAGE-ESM-026 and is gap-fill with hand-written event-type migrations, and a reference to a historical revision is refused with STAGE-ESM-025
AI (Release v7.11.3): The skills target the cratis CLI 3.28.3, which bundles Stage 4.24.2 and reports an evolved event with STAGE-ESM-026 instead of CLI-RENDER-003, and the agent harness images install it
cli (Release v3.28.3): The CLI bundles Stage 4.24.2, so cratis render renders ESM v4 models whose events are at their first revision, and reports an evolved event with Stage’s STAGE-ESM-026, which names the event and its revision, instead of the CLI’s own CLI-RENDER-003
Stage (Release v4.24.3): The Stage host uses the shared Cratis OpenTelemetry setup. Every Cratis.* trace source and meter, including the Chronicle client, is now subscribed, and OTLP export follows the standard OTEL_* configuration. (#191)
Stage (Release v4.24.2): Stage renders ESM v4 models, which Screenplay produces for models with evolved events, as long as every event they use is at its first revision; v1 to v3 models render exactly as before (#165)
Stage (Release v4.24.2): An evolved event, or anything that depends on one, is refused with STAGE-ESM-026 until Stage can render the Chronicle event-type migrations it needs, and a reference to a historical revision is refused with STAGE-ESM-025 (#165)
AI (Release v7.11.2): The Screenplay and Stage skills target the cratis CLI 3.28.2, which bundles Screenplay 4.66.0 and Stage 4.24.1: cratis screenplay validate now binds Automation and Translate slices, cratis render still refuses ESM v6 models with STAGE-ESM-016, and guidance for the older bundle applies before 3.28.2 (#500)
AI (Release v7.11.2): The Screenplay skills describe 4.66.0’s named-rule implementation blocks: accepted on handlers, operation phases and command named rules, refused on concept rules, built-in property rules and whole-command bodies (#500)
AI (Release v7.11.2): The Stage skills describe Stage 4.24.1 and its STAGE-ESM-024 ledger diagnostic, and the model-first reference describes where cratis 3.28.2 places and finds Screenplay models (#500)
AI (Release v7.11.2): The agent harness images install the cratis CLI 3.28.2 (#500)
AI (Release v7.11.1): In a repository with several packages and no root package, a change outside every package now stops the quality gate with an explicit “unverified” result instead of passing (#487)
cli (Release v3.28.2): The CLI bundles Screenplay 4.66.0, Stage 4.24.1, the Arc source adapter 22.50.5, Chronicle 19.32.0 and Fundamentals 7.22.8. cratis screenplay validates with the same compiler Stage renders from; Stage still renders ESM v1 to v3 only (#253)
Chronicle (Release v19.32.2): PII identifiers that start with Chronicle’s reserved encrypted-value marker are now rejected before any key is provisioned or value encrypted. (#4553)
Chronicle (Release v19.32.2): Revising an event and migrating stored events to a new generation now fail, rather than store empty values, when a protected value cannot be released because a key lookup or decryption fails. Values whose subject has been erased are migrated as erased. That includes ciphertext that no longer decrypts after a recorded erasure followed by a new key for the subject. (part of #4456) (part of #4525)
cli (Release v3.28.1): cratis screenplay mcp run outside a project, with no path or --project-root, no longer creates a Screenplay folder in the working directory. The server picks its workspace itself: the host’s workspace roots, else Documents/Screenplay in your home folder.
AI (Release v7.11.0): Agents, skills, prompts and harness copies no longer treat .cratis/screenplay/ as the model root. A Screenplay model lives where the project’s .play files already are, else under Source/ or src/, else in a Screenplay/ folder at the repository root. A model already in .cratis/screenplay/ keeps working.
AI (Release v7.11.0): Screenplay model guidance describes the MCP default for chats with no project: Documents/Screenplay in the user’s home folder.
Screenplay (Release v4.67.0): The ChatGPT desktop plugin no longer pins a model directory in its plugin data folder; it uses the same defaults.
AI (Release v7.10.0): The Screenplay MCP descriptor no longer declares defaultRoot, and the PI cratis-mcp extension starts without a .cratis/screenplay directory. The Cratis CLI locates the model: the existing .play files, else Source/ or src/, else a new Screenplay/ folder. An explicit mcpServers.screenplay.root is still honored. Requires the Cratis CLI release that ships this behavior.
Stage (Release v4.24.1): Stage builds on Screenplay 4.66.0, Arc 22.50.5 and Chronicle 19.32.0, and the development host runs the matching Chronicle 19.32.0 kernel. Models up to ESM v3 render exactly as before; ESM v6 models stay refused (#200)
cli (Release v3.28.0): cratis ai install and cratis ai update no longer create or require .cratis/screenplay/. Only an explicit mcpServers.screenplay.root in .cratis/ai.json names a model directory, and that directory must exist. A model already in .cratis/screenplay/ keeps working.
AI (Release v7.9.3): The Screenplay and Stage skills say plainly what event sources, streams and command routes reach today: they can be authored and validated, but they do not bind, their specifications do not run, and Stage does not render them, so their realization is gap-fill with the model as the contract (part of #500)
AI (Release v7.9.3): The Chronicle .NET client and Arc command skills cover event source definitions: IEventSource, [EventSource] and [EventStream] with the routing fields on EventForEventSourceId (Chronicle 19.30.0 and later), and [EventSource<TSource>(stream)] on commands (Arc 22.49.0 and later) (part of #500)
Screenplay (Release v4.66.1): MCP executionReadiness for commands, specifications, slices and the model now names every unadmitted feature with its tracking issue, in a fixed order, instead of a single required version number. (part of #309)
Chronicle.Go (Release v0.4.0): Strict read-model scenarios (ReadModelOptions.StrictEventSubscription) now decide whether a seeded event is subscribed the same way the kernel does for the projection. Children, joins, nested scopes, removal events and derived event types all count, and keys do not. Strict scenarios no longer refuse relationship, custom-key or mixed-All projections when they open. Unsubscribed seeds are still rejected in Given with ErrUnsubscribedEventSeeded before anything is appended. Reading results for those profiles still returns ErrUnsupported (part of #38)
release-action (Release v1.4.2): HTML comments (“) are removed from the release notes before the release is created, so pull request template guidance left in a description is no longer published in the release body. Comments shown inside fenced or inline code are kept, and notes holding nothing but a comment count as empty, so GitHub generates them (#195)
release-action (Release v1.4.2): Issues are closed from the published notes, after comments are removed: a (#n) written only inside an HTML comment no longer closes the issue (#195)
Chronicle.Go (Release v0.3.0): captures.Service.Validate and Save return ErrUnsupported for a definition that carries source authorization, before anything is sent to the kernel, so credentials are never silently dropped. The kernel’s capture contract cannot carry authorization yet (Cratis/Chronicle#4591) (part of #37)
Chronicle.Go (Release v0.3.0): A webhook source rejects blank credentials and more than one authorization option at Build; C# keeps only the last option (part of #37)
Chronicle.Go (Release v0.3.0): json.Marshal and json.Unmarshal of capture Source, Definition, Builder and SourceAuthorization now fail with ErrUnsupported instead of producing {}, so credentials cannot be serialized or silently decoded as no authorization (part of #37)
AI (Release v7.9.0): Discovery, slice design, streams, automations and translations, render and gap-fill, and toolchain guidance follow Martin Dilger and Nebulit GmbH’s wording, checklists and output formats more closely, for example storylines, events with no fields, per-record translation contracts and stream decision trees (#497)
AI (Release v7.9.0): The Screenplay Modeler, Screenplay Reviewer, Screenplay Renderer and Slice Implementer agents point to the adopted per-run protocol, business-question lens and delivery discipline (#497)
AI (Release v7.9.0): Each affected skill’s provenance and LICENSE now credit Martin Dilger and Nebulit GmbH, with their agreement, alongside the existing TrogonStack MIT notices (#497)
AI (Release v7.7.1): Agent harness images (base, Claude, Pi and Copilot) now ship the latest tooling: Claude Code 2.1.285, Pi 1.0.3, GitHub Copilot CLI 1.0.92, Cratis CLI 3.27.1, rtk 0.51.0, Helm 4.3.0, Gradle 9.8.0, Kotlin 2.4.20, OTP 29.1.1, Playwright 1.63.0, mongosh 2.13.0, Headroom 0.39.1 and the Roslyn language server 5.12.0-1.26475.2.
AI (Release v7.7.1): The bundled MCP servers and Pi extensions are updated to their latest releases, including pi-mcp-adapter 5.0.0 and @gotgenes/pi-anthropic-auth 3.4.2.
AI (Release v7.7.1): A Pi worker now requires DIRECT_MODEL: Pi 1.x rejects --provider without --model, so a worker started without a model exits with a clear message instead of failing inside the CLI.
AI (Release v7.7.0): cratis-screenplay-event-modeling is now the entry point. It holds the model-first decision and routes to the method skills. (#493)
AI (Release v7.7.0): The language skills now state, at Screenplay 4.64.0, which compiler admits reactions, clocks and captures, and what binds and what renders. The MCP guidance covers identity-preserving edits, the source-map view and the whenAppendedEvent label. (#434)
AI (Release v7.7.0): cratis-stage-rendering-and-sandbox describes cratis render on Stage 4.24.
AI (Release v7.7.0): The planner, coordinator, orchestrator and code reviewer choose the model level when a repository has opted in.
AI (Release v7.7.0): The slice implementer, backend developer, spec writer and frontend developer start from the contract.
AI (Release v7.7.0): The spec writer seeds prior state with _scenario.Given. (#492)
AI (Release v7.7.0): The rules, prompts and code-level skills find the contract first, and route model-level work back to Screenplay when a model covers it.
AI (Release v7.7.0): The specification skills take their list of specs from the contract and cover read-model lifecycles, and the reactor skill covers repeated delivery.
Screenplay (Release v4.66.0): The VS Code board and local language assistance remain available in Restricted Mode, while C# repair processes require workspace trust. Workspace overrides for source roots and repair settings are restricted until the workspace is trusted. (part of #341)
Screenplay (Release v4.65.0): implementation blocks are rejected on concept rules, built-in property rules and whole-command require/validate bodies, with matching diagnostics in both compilers and the editors. Files without implementation blocks parse, print and serialize as before. (part of #307)
Screenplay (Release v4.64.0): Valid numbers exact documents report PLAY0268 when bound, because ESM v7 is not admitted yet. Files without the preamble parse, print and serialize exactly as before. (part of #285)
Screenplay (Release v4.64.0): MCP tools refuse to return exact numbers through the older fixture format rather than rounding them. (part of #285)
Chronicle (Release v19.32.0): Generated shared enums in the contracts now carry the documentation of their source enums, and optional enum query arguments are supported in generated requests (part of #4424)
Arc (Release v22.77.0): The Screenplay generator no longer states a reactor that returns several events as produces when Chronicle could refuse the batch differently from Screenplay: Chronicle appends a returned batch as one unit, while a Screenplay reaction appends each fact separately. When a later event can be rejected by a constraint (a unique property, a class-level [Unique], or an IConstraint target), an earlier event closes the stream, or a constraint cannot be read, the reactor keeps its file reference and SP0070 explains why. (part of #3093)
Arc (Release v22.77.0): The Screenplay generator reads screen source with a scanner that understands strings, template literals, regular expressions and JSX text and attributes, so // inside a value such as title="https://example.com" is no longer cut off as a comment and an import inside a template literal is no longer read as an import. A screen that renders other components or HTML beside the Cratis Components it reads now reports each part it does not read with SP0028, and a screen whose source cannot be scanned reports that once instead of stating a partial structure. (#3095)
AI (Release v7.35.0): Arc identity guidance: forwarded identity headers are trusted only with TrustForwardedIdentityHeaders=true, discovery endpoints need authentication outside Development, and the `.cratis-iden
Chronicle (Release v19.51.0): In-process MongoDB integration runs no longer intermittently overcount keyed events or let observers from an earlier test context consume the next context’s events. (#4787)
Arc (Release v22.75.2): The Screenplay generator no longer drops then returns when a scenario reads the result through the null-forgiving operator (result!) or passes it as an in argument; these are reads, not writes. (#3092)
Arc (Release v22.75.2): The Screenplay generator no longer states a command response as then returns when the scenario changes it before asserting: a write through any member or element of the executed result (assignment, ++/--, ref/out, including null-conditional chains), or a copy of the result or of a reference read through it (into a variable, field or initializer, a foreach, a pattern variable, or a returned, yielded or lambda value, also through ?:, ??, tuples and collection expressions), now keeps the response from being stated and reports the scenario instead. (#3092)
Arc (Release v22.75.1): CommandScenario now runs a command as the caller a specification registers: a substituted ICurrentPrincipalAccessor, ICurrentPrincipalOverride or IAuthorizationPolicyRuntime added to the scenario’s services is kept instead of being replaced by Arc’s defaults, so specifications of role- or policy-protected commands are authorized or denied by that caller, as the documented setup describes. (#3184)
Chronicle (Release v19.50.1): An observer no longer skips events when the storage lookup for its next relevant event fails. It keeps its position, stays in routing without delivering anything, and retries on the next watchdog pass instead of fast-forwarding to the tail. (#4770)
Chronicle (Release v19.50.1): The observer documentation now matches the current behavior: projection replay and catch-up run as one ordered step, [OnceOnly] excludes replays rather than limiting a handler to one run per event source, and the quarantine and replay descriptions in the observers concept page are corrected. (part of #4748)
Arc (Release v22.74.0): The Screenplay generator now reports two same-named concepts as ambiguous (SP0031) when they differ in pii, secret or the stated encryption scope, instead of declaring one with the other’s compliance claims. (#3096)
Arc (Release v22.74.0): The generator now leaves pii and secret off a concept only when the generated document actually uses it as an identifier, event-source identity, stream id, stream-id route mapping or for destination, which Screenplay rejects (PLAY0515). Concepts that are identifiers only in code the document does not state keep their annotations, and SP0059 now names each use that caused an annotation to be withheld. (#3096)
Arc (Release v22.73.0): Proxy generation consistently selects one image per assembly identity when application and framework directories contain different copies, and ignores optional native runtime images without hiding invalid required managed inputs. (#3163)
Arc (Release v22.72.1): The Screenplay generator no longer states a command’s source and stream route when one of its productions is explicitly routed or not proven to use the command’s context, whatever the identifier type. Commands identified by a Uuid, a Uuid-backed concept, or no identifier type previously kept a route that claimed those events land on the command’s stream; the whole route is now withheld and reported with SP0054, in both default and authoring output. (#3097)
Arc (Release v22.72.0): Commands returned by a reactor marked [ExecuteCommandsAsSystem] no longer leave the caller authenticated as the system actor. The execution identity is contained within the async command scope and is cleaned up on success, rejection, exceptions and service-resolution failures. (#3177)
Arc (Release v22.71.0): Model-bound command proxies no longer type Chronicle event values as client responses when their declared shape is handled by the event integration. Mixed returns retain the client identifier or DTO. MVC controller outputs, object collections, and unsupported collection shapes remain client responses. (#2885)
Chronicle (Release v19.50.0): Reactor and reducer dispatch caches are isolated to each client’s event registry, so registrations from one client cannot change which events another client handles. Registry changes invalidate cached dispatch maps. (part of #4732)
Chronicle (Release v19.50.0): Event dispatch includes exact registry-known event types without an [EventType] attribute, while retaining base/interface dispatch and historical-generation exclusions. (part of #4732)
Chronicle (Release v19.50.0): Reactor delivery identities, event-sequence inference and implicit external-store subscriptions consistently use registered event identities and store metadata. Private helpers referencing events outside a filtered registry no longer cause observer discovery to fail. (part of #4732)
Chronicle (Release v19.50.0): Event-target read-model registration and child event-property mapping resolve event identities through the client registry, preserving existing publication checks and identity defaults. (part of #4732)
Screenplay (Release v4.139.0): The event-generation documentation clarifies that an opted-in Chronicle projection pins the latest registered generation when it is registered. This provider registration rule does not change Screenplay’s existing generation resolution.
Stage (Release v4.73.1): The running Stage served the Scene document with each enumeration spelled like its .NET name ("kind":"Dialog"), while the Scene model reads dialog. The Scene navigation host therefore resolved a dialog destination to nothing and the toolbar’s dialog item did nothing - found by running the public acceptance vector against CLI 3.53.0 / Stage 4.73.0, which a generated application never showed because the renderer plans the document with the model’s spelling. /stage/scene now uses the same spelling (SceneEnumerationNaming’s lists, pinned together by a conformance specification) and writes nothing for a member with no value. (part of #237)
Arc (Release v22.69.1): Observable queries over plain HTTP now apply read-model interception and emission guards to cached and later results, for both model-bound and controller queries. Denied results return no data, suppressed results wait for an allowed emission only when requested, and failures respect ExposeExceptionDetails. (#3155)
Arc (Release v22.69.1): Async-enumerable queries now apply read-model interception over the query hub and plain-HTTP controller endpoints. (#3155)
Chronicle (Release v19.49.0): Projection preview, used when querying a projection declaration from a client and in the Workbench projection editor, now returns the documents the saved projection would persist. Keyed child updates update the existing child instead of adding a duplicate, removed children are removed, and join events from another event source update every read model they join into instead of creating documents of their own (#4727)
Chronicle (Release v19.49.0): Child projections computed on demand for a single read model no longer keep children removed with RemovedWith (part of #4542)
Chronicle (Release v19.49.0): When a child is removed through RemovedWithJoin, the parent read models it belonged to still receive their every-event mappings (#4725)
Chronicle (Release v19.49.0): The documentation examples for model-bound child updates, child joins and child removal through a join now match how child joins correlate, so they run as described (#4725)
Stage (Release v4.71.1): Executing a command with a required property missing, or with a value that breaks a modeled rule, now answers with a validation failure naming the offending properties instead of a 500 “internal error”. Before, the missing property was only caught by the event store’s schema check, and the modeled validation rules were never run when a command executed.
Screenplay (Release v4.135.1): A specification example can now be typed by an event, command or read model imported from another document. When a document is checked on its own, the example is accepted like an inline given, and its values are checked when the compilation includes the imported declaration. The TypeScript compiler now reports PLAY0520 for an example whose type is unknown, ambiguous or of the wrong kind, matching the .NET compiler. See https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/specifications.md (#648)
AI (Release v7.29.1): The Screenplay contract sync no longer fails after a clean comparison when the screenplay-sync label does not exist yet, so a real drift now opens its tracking issue (#602)
Screenplay (Release v4.135.0): Whole-number literals with 16 or more digits, such as 9007199254740991, and long fractions such as 0.10000000000000002, now keep their exact value in the executable model instead of being rounded to 15 significant digits. A model with such a literal outside a route compiles at the new ESM v11. Every other model keeps its version, bytes and revision, and v1–v10 models from other producers are still accepted with any decimal. Consumers have to admit v11 explicitly. See https://github.com/Cratis/Screenplay/blob/main/decisions/0064-exact-number-literals-claim-esm-v11.md (#639)
Chronicle (Release v19.46.0): A ReactorScenario handler that throws synchronously now surfaces its own exception instead of a TargetInvocationException wrapper (part of #3912)
Stage (Release v4.68.1): Generated command handlers now refuse a whole-number stream-id value outside ±9007199254740991, the bound Screenplay applies. They return a validation error naming the property, and no event is appended. Composite stream ids check each part in order before producing any event. Before, a value such as 9007199254740992 became a stream id that Screenplay’s reference rejects. (#324)
Orleans (Release v1.16.3): A job step whose job is removed now has its stored state deleted. It used to be saved again and stay until the job’s own state was cleared (#71)
Chronicle (Release v19.45.0): A model-bound [Join<TEvent>] inside a [ChildrenFrom] collection without on: now joins on the child’s identifying property, so join events that happened before the child was added are applied. If the child has no identifying property of its own, building the projection fails with MissingChildIdentityForJoin instead of silently missing those events (#4724)
Chronicle (Release v19.45.0): The declarations Workbench shows for registered projections target the full read-model identifier, so they save back unchanged (#4729)
Chronicle (Release v19.45.0): The projection editor’s generated declarative and model-bound C# now compiles and expresses the same projection as the PDL: child joins without .On(), keyed removals, every blocks, child removals, nested objects, child and nested records with typed properties (DateTimeOffset, Guid, nullable types, collections), and self-referential read models. Where an attribute or builder cannot express a construct, the generated code says so in a comment instead of emitting different behavior (#4728)
Screenplay (Release v4.133.3): A property tooltip no longer stays open at a stale position after the board pans or zooms under a still pointer; it closes when its card is no longer under the pointer and follows the card while it is.
Screenplay (Release v4.133.3): In features with sub-features, the slices of a parent and of its children start at the same height, so the row labels line up with every column.
Orleans (Release v1.16.2): An explicit IJobsManager.Rehydrate() call that arrives just as a background drain finishes now starts a new pass. It used to be skipped, so newly interrupted jobs waited for the next call or a host restart (#68)
Orleans (Release v1.16.2): A job step stopped before PerformStep runs (while waiting for a throttle slot, right after acquiring one, or before its work starts) now reports itself as stopped to its job exactly once, so the job completes its stop and runs OnStopped. Job steps that report this outcome themselves from a PerformWork override must remove that code, or the job counts the stop twice. A step whose grain deactivates without a stop request, for example on silo shutdown, still stays scheduled and resumes after restart (#69)
Stage (Release v4.65.1): The cratis/stage Docker image build failed in the frontend stage because sceneEnumerationNaming.spec.ts imports the checked-in Scene enumeration map from outside the frontend build context, so tsc -b reported TS2307 and v4.65.0 published no image. The map is now copied into the frontend stage at the location the spec expects.
Scene (Release v4.18.1): The PrimeReact data table states a column’s sort order with aria-sort on the column header instead of on the sort button, where it is not allowed. (part of #73)
Scene (Release v4.18.1): The PrimeReact progress bar has an accessible name: its label property, or Progress. The dashboard template’s capacity bar is labeled Warehouse capacity. (part of #73)
Chronicle (Release v19.42.0): A class implementing two IProjectionFor<> or two IReducerFor<> interfaces, directly or through a base class, is no longer silently skipped at startup. Discovery now fails with TypeImplementsMultipleProjectionInterfaces or TypeMustImplementOnlyOneReducer, naming the class, so split it into one projection or reducer per read model. (#4734)
Chronicle (Release v19.42.0): ContainerName() on a fluent projection now sets the container (collection or table) the read model is stored in. It used to replace the read model identifier, so the projection pointed at a read model that did not exist. The read model keeps its identifier, and two projections that give one read model different container names are reported as a conflict. (#4735)
Arc (Release v22.67.1): Model-bound queries in assemblies without generated query metadata are discovered again when another assembly contributes generated metadata. Generated metadata is still used for the assemblies it covers. (#3142)
Stage (Release v4.63.1): The Stage Host can now rebuild its state from events whose enum values were stored as numbers, which is how Chronicle stores them for applications Stage renders. Before, rebuilding from those events failed. A number maps to the member at that position in the model, and declared member names still work. Out-of-range, fractional or undeclared values are refused rather than misread. (part of #296)
Stage (Release v4.63.0): Specifications that Stage renders now escape text values correctly. Before, a value containing a newline, quote or backslash could produce generated C# that did not compile or that tested a different value.
Chronicle (Release v19.40.1): A projection child that arrives before its parent is no longer lost when the write of the resolved child fails. The stored future is kept until its write succeeds, and the failure is reported as a failed partition so the partition is retried. (#4740)
Chronicle (Release v19.40.1): The MongoDB storage no longer risks creating two clients for the same server set when the first connections happen at the same time. (#4741)
Chronicle (Release v19.40.1): An append that is renumbered after a competing write took its sequence number now checks its concurrency scope again before writing. When the expectation no longer holds, the append returns a concurrency violation instead of being written. (#4742)
Chronicle (Release v19.40.1): MongoDB 8.2 is now the default image for local development, the Aspire integration (MongoDBTag), the development image and the hosting examples. MongoDB 8.0 does not start on Linux kernel 6.19 and newer, which current Docker Desktop releases ship. (#4743)
Stage (Release v4.62.0): The Stage Host and semantic executor now check a model’s ESM version themselves and refuse versions Stage has not audited with STAGE-ESM-016. Before, a v9 public event or event origin outside a Translate slice loaded into the Host without being detected.
Stage (Release v4.61.0): The renderer target guide states that cratis render forwards requirements, bodies and typed-context descriptors; the Host does not forward descriptors yet.
Orleans (Release v1.16.1): Stopping a job step while it waits for a throttle slot or performs its work now ends in a normal cancellation, instead of a NullReferenceException from JobStep.PerformWork. Code that caught NullReferenceException around base.PerformWork can drop that catch (#65)
Orleans (Release v1.16.1): A job step that was stopped can be started again in the same activation; Start used to fail with an unknown error (#65)
Arc (Release v22.65.5): Hosted Arc applications using Chronicle now resolve IEventSources without manual registration, so commands with [EventSource<T>] and aggregate roots that declare an event source run outside CommandScenario too. Arc now references Cratis Chronicle 19.39.1. (#3119)
cli (Release v3.46.1): cratis screenplay mcp --project-root no longer creates a Screenplay/ folder when it starts in a repository without a model; the folder is created only when the first model document is written, so installing the Screenplay MCP server leaves no trace in a code-first repository; the reference documentation describes the new behaviour (#311)
cli (Release v3.46.0): Corpus rules scoped to a cratis/<profile> (such as the CodeScene policy) are installed only when the repository selects that profile or one nested under it, instead of in every repository (#312)
Stage (Release v4.59.0): The syntax-based CratisRenderer renders every case of a specification table instead of failing on the table. SpecificationRenderer.Render refuses a whole table with an InvalidEventModel that asks for one call per case. (#256)
Screenplay (Release v4.130.1): $ in a matches rule now means the end of the input in the C# compiler, as it already does in JavaScript. A value with a trailing newline, such as "ABC\n", no longer passes ^[A-Z]{3}$, and the built-in email rule rejects it too. An escaped \$ and a $ inside a character class stay literal. (#617)
Components (Release v4.26.4): PivotViewer no longer leaves blank spaces in the card area after a large jump, such as dragging the scrollbar, pressing End or zooming out. Cards on screen are drawn first, and the cards around them keep loading on the following frames after you stop scrolling. Cards that are on screen are also no longer removed when a view transition finishes after the layout has changed. (#236)
Arc (Release v22.65.4): An aggregate root without a declared event source no longer gets a concurrency violation when an event type it does not handle is appended for its id after it was loaded. Once the aggregate exists, its commit conflicts only with event types it applies. A new aggregate still rejects a concurrent create of any event type. (#3127)
Ante (Release v1.3.0): Opening a second invitation link with the same login no longer replaces the session of the first, so the first invitation no longer fails with “Invitation is no longer pending” while it is still pending. Sessions are stored per invitation; the old per-login unique index is dropped when the application starts.
cli (Release v3.43.1): cratis screenplay generate, cratis screenplay conform and cratis view no longer fail in the native single-file CLI on machines whose installed .NET SDK is newer than the CLI’s bundled runtime; projects are evaluated only by the out-of-process build host, which selects the installed SDK for each project (#50)
cli (Release v3.43.1): The native single-file CLI finds framework reference packs in the installed .NET SDK (through DOTNET_ROOT or the dotnet on PATH) instead of looking next to its bundled runtime (#50)
AI (Release v7.26.0): The legacy-extraction skill uses cratis screenplay generate instead of a bare screenplay generate. (#529)
Chronicle (Release v19.39.1): AddCratisChronicle now registers IEventSources as a scoped service, the same way as the event log, read models and the other per-store services. Code that declares an event source can now resolve it from the container in a hosted application: an Arc command with [EventSource<T>("stream")], or an event-sourced aggregate root. Before, it failed with “No service for type IEventSources” before the command ran. (#4718)
cli (Release v3.43.0): cratis chronicle login honours the connection string’s certificatePath the same way every other command does: it presents it as a PKCS#12 client certificate, with or without a password, so login works against servers that require client certificates and against publicly trusted servers when a client certificate is configured (#198)
cli (Release v3.43.0): cratis chronicle login reports a clear error when the configured client certificate is missing, invalid or has the wrong password (#198)
cli (Release v3.43.0): A stored login made against an IPv6 server address is recognised when the same server is written differently, such as [::1] and [0:0:0:0:0:0:0:1] (#198)
Arc (Release v22.65.1): A CommandScenario with Chronicle now runs commands that declare [EventSource<T>("<stream>")], and commands on event-sourced aggregate roots, without registering any services by hand. The scenario provides IEventSources and the event serializer from its own event store. Appended events carry the route taken from the definition. scenario.EventRoutes now works without decision reads, and services a test registers itself still take precedence. (part of #3119)
Chronicle (Release v19.38.2): Registering a new generation of an event type no longer overwrites stored event content. The backfill only adds the generations an event is missing, migrating from the generation the event was appended in, or from the highest stored generation when that is unknown. It never writes over a redaction or a revision made while it runs. The backfill still covers only the default namespace’s event log (#4709)
Stage (Release v4.56.1): Two domains with the same module, feature, slice and operation names can now be planned into one application, in one plan or in separate per-domain plans, without overwriting each other’s authorization. When a domain is set, per-operation policy files, opaque policy bodies and typed-context wrappers go under {Domain}/, in domain namespaces. Each generated authorization policy name includes the domain. Before, rendering a second domain silently replaced the first domain’s policy for an operation with the same name. Plans without a domain are unchanged. (#283)
cli (Release v3.41.1): The Chronicle diagnose slash command that cratis init writes for AI tools now runs cratis chronicle observers list, cratis chronicle failed-partitions list, cratis chronicle failed-partitions show and cratis chronicle recommendations list instead of failing with “Unknown command” (#267)
cli (Release v3.41.1): Help text, option descriptions, error hints and the package README now name Chronicle commands with their chronicle prefix, so commands copied from them run (#267)
Arc (Release v22.65.0): Observable and collection queries that Screenplay now admits bind clean instead of being tolerated as refusals. Same-named queries in different slices are a known Screenplay binder limit: https://github.com/Cratis/Screenplay/issues/624. (#3090)
Screenplay (Release v4.127.1): The editors now warn PLAY0347 when an earlier when alternative of a click, double-click or select interaction already covers a later one, as the C# compiler does, with the same message (#576)
Stage (Release v4.55.0): For ESM v6 models and later, a specification that appends an event directly now compares its then events only with the events that followed the append, as Screenplay’s reference runner does. Before, the appended event itself could satisfy the expectation, so a specification could pass in Stage and fail in Screenplay.
Chronicle (Release v19.38.1): Chronicle now records the generation each event was appended in, in MongoDB, SQL and in-memory storage, for single, batch and publication appends. Redacting an event keeps it. Events appended before this release read it as unknown. This prepares consistent generation delivery and lossless migration backfill (part of #4189) (#4708)
Screenplay (Release v4.124.1): @cratis/screenplay-language publishes its runtime as one module per source file, so a consumer’s bundler can split it. Before, everything shipped as one prebuilt shared chunk of about 508 kB, too large for a 500 kB chunk budget. Entry points and the exports map are unchanged (#612)
Screenplay (Release v4.124.1): The package build fails when any published JavaScript file exceeds 500 kB, and the package README lists where the runtime’s bytes go (#549)
cli (Release v3.41.0): cratis screenplay generate no longer refuses a project that references a package adding compile items from inside its own folder, such as Microsoft.NET.Test.Sdk. Every application cratis render produces references it, so recovery always stopped with CLI0017. (part of #284)
cli (Release v3.41.0): Recovering a rendered application now declares the read models its queries and projections return, so the recovered model binds. (part of #284)
Stage (Release v4.52.0): A modeled value of an enum concept now renders as its enum member, so a generated backend that uses one in a command or specification compiles. (part of #236)
Stage (Release v4.52.0): Generated query specifications declare only the result field their query assigns, so the generated Debug build has no unused-field warning. (part of #236)
Stage (Release v4.52.0): An authored action with no planned route now uses the command route the running application registered, and stays disabled when there is none. (part of #237)
Stage (Release v4.52.0): After a successful command, Stage reads the screen’s queries again once an asynchronous projection has had time to apply it, so the screen shows what the command did. (part of #237)
Chronicle (Release v19.38.0): Projection tags sent at registration are now stored and returned by the kernel instead of being dropped. A change that only affects tags is saved without replaying the projection (#4512)
Chronicle (Release v19.38.0): The projection tagging and filtering documentation now says that TypeScript projections can be tagged with @tag and @tags (#4513)
Chronicle (Release v19.38.0): The constraint documentation now describes unique constraints as one value per event source, unique across event sources (part of #4641)
Arc (Release v22.64.1): An aggregate root’s commit now guards every event its rehydration read, so a concurrent append in another stream for the same event source id is reported as a concurrency violation instead of being silently missed (#2796)
Arc (Release v22.63.1): Generated proxies for model-bound queries offer sorting helpers for the read model’s fields instead of the query’s parameters, so every helper names a field the server can sort by (#2998)
Stage (Release v4.51.3): A screen’s data binding now resolves to the query it names. A list declared as data AllWorkItems calls all-work-items and shows every work item, instead of the WorkItemById lookup over the same read model, which returned nothing without an argument. (part of #236) (part of #237)
Stage (Release v4.51.3): Every modeled query is served under its own name, including queries without a by parameter, so /stage/routes maps AllWorkItems, WorkItemById and CommentsForWorkItem to their own routes. (part of #236) (part of #237)
Stage (Release v4.51.1): A scene element querying a read model that backs more than one modeled query (for example AllWorkItems and WorkItemById, both returning WorkItemSummary) now resolves to the correct route. Previously, StageSceneRoutes matched candidates by the read model’s type name alone and broke the tie by shortest route text; Arc names the conventional argument-less collection endpoint from the read model’s pluralized name, which can be textually longer than a by-id route, so the by-id route was sometimes picked for a table that needs the collection. The element’s own modeled query name (now carried in SceneElementProperties.Query) is tried first, and when that does not resolve, a by-id lookup is excluded from the remaining candidates before falling back to the shortest route. (part of #236) (part of #237)
Arc (Release v22.62.0): Named tags set on a returned EventForEventSourceId are no longer dropped when the event is appended (#2570)
Chronicle (Release v19.37.9): Reducer string-array properties round-trip through Mongo and SQL sinks and the reducer transport without being flattened to a scalar, with specs that guard parity across both storage providers and the PII and subject-erasure paths for array elements.
Chronicle (Release v19.37.8): Projection futures now keep the full event context in storage, so a child resolved from a future after a restart, grain deactivation or replay is projected with the original event’s occurred time, causation, correlation, caused-by, tags, routing and subject instead of defaults. Values mapped with [SetFromContext] (for example Occurred) are no longer silently wrong for such children. Futures stored by earlier versions still load as before. SQL storage gets an EventContextJson column on the projection futures table through a migration (#4667)
Stage (Release v4.50.1): Modeled queries narrowed with by (for example CommentsForWorkItem by workItemId) are now served under their own route and return only the instances that match the argument, instead of every instance of the read model. A missing or empty argument returns an empty result. (part of #236) (part of #237)
Stage (Release v4.50.1): The conventional All<ReadModels> route applies the same narrowing when a caller supplies a modeled by parameter, so all-comment-views?workItemId=<id> no longer returns other work items’ comments. (part of #236) (part of #237)
Chronicle (Release v19.37.7): Docker image publishing logs in to Docker Hub before setting up QEMU, so pulling the binfmt image is no longer subject to the anonymous pull rate limit that failed every image job of a release.
Chronicle (Release v19.37.6): Reactor registration compares persisted metadata against the runtime’s unrestricted sentinels, so unchanged definitions are no longer rewritten on every restart or reconnect.
Chronicle (Release v19.37.6): Startup retries under storage saturation are bounded, honor shutdown, and never continue past a required step that failed.
Chronicle (Release v19.37.6): SQL storage no longer writes an event type’s display string into its id column for reactor definitions; malformed rows are rewritten on the next registration.
Chronicle (Release v19.37.6): A read model’s definition is not rewritten when unchanged, and a failed write no longer leaves in-memory state ahead of storage.
Components (Release v4.26.3): The connector line between steps in a horizontal stepper no longer runs through the step names; it now runs between the step numbers and shows in forced-colors mode (#411)
Chronicle (Release v19.37.5): A persisted partition job step whose observer was later unsubscribed or retired threw Argument type must be an interface while activating, so it failed and was retried continuously, flooding the kernel log and burning CPU. It now activates and reports the disconnection the job already handles.
Chronicle (Release v19.37.4): Appending a batch for several event sources where some events carry named tags now keeps the registered event source of every event in the batch, so registered-source metadata and definition validation apply to those batches and to unit-of-work commits, as they already did for single appends (#4603)
Stage (Release v4.49.11): The Stage Host now returns every matching read model for a list query instead of only the first. An unkeyed list query no longer advertises an id parameter, and a keyed list query takes its parameter under its modeled name.
Stage (Release v4.49.11): Rendered read models no longer mark a list query’s by property as the read-model key. Only single-result lookups set [Key].
Stage (Release v4.49.11): An authorized unkeyed query now gets its generated authorization policy registered, so the [Authorize] attribute on it no longer points at a missing policy. An authorization rule that needs a query argument the query does not have is refused with STAGE-ESM-015. (#261)
Chronicle (Release v19.37.3): EventSourceId<T> now turns numeric, date and time values into event source ids, and parses them back, with the invariant culture, so the same identity names the same stream on every machine. A decimal id of 123.45 is "123.45" under nb-NO too, instead of "123,45" (#4651)
Chronicle (Release v19.37.3): Typed event source ids over DateOnly, DateTimeOffset, TimeOnly and TimeSpan, and over concepts that wrap numbers or dates, can now be converted back from an untyped EventSourceId instead of throwing
Chronicle (Release v19.37.2): Several applications registering into the same event store each sent a “full set” that retired every client-owned projection not in its own set, including the other applications’. They retired and re-registered each other’s projections in a loop, which saturated the projections manager and made Register time out. A full set now only retires projections the same application registered; the client identifies itself with its entry assembly name, and a full set from a client that does not identify itself retires nothing.
Stage (Release v4.49.10): Stage tables that navigate on a row click now carry the selected row’s identity in the address (#/WorkItemDetails?workItemId=...), restore the selection from a deep link, and clear it from the address when the selection is cleared. (part of #236) (part of #237)
Stage (Release v4.49.10): Tables fed by a data ... by <parameter> declaration now read through that declaration’s query with the selected identity, so a details screen shows only the selected item’s rows, ignores a delayed response for a previously selected item, and reads nothing while no item is selected. (part of #236) (part of #237)
Stage (Release v4.49.10): Native command forms on a screen navigated by a parameter now start with that parameter in the same-named command input, so Rename and AddComment submit for the selected work item; inputs with no matching parameter, such as a new comment’s identity, stay required user input. (part of #236) (part of #237)
Stage (Release v4.49.10): Switching the Scene theme now repaints the page body background and text color, not only the shell. (part of #236) (part of #237)
Stage (Release v4.49.9): Authored command actions in /stage/scene now include modeled command schemas, required metadata, and field descriptors so native command forms can render and validate inputs before submission. (part of #236) (part of #237)
Stage (Release v4.49.9): Stage marks missing command metadata separately from intentionally parameterless commands, keeping unsafe command actions fail-closed instead of submitting empty payloads. (part of #236) (part of #237)
Ante (Release v1.2.11): The wizard’s form and step header sat flush against the card edge, because their padding was written for PrimeReact’s stepper classes that Cratis Components 4 no longer renders. The card also touched the window edges on narrow screens.
Chronicle (Release v19.37.1): Reconnecting clients no longer stall the kernel by re-registering unchanged read models: registration now compares definitions by value and only persists and pushes new or changed read models, instead of rewriting every read model on every attempt.
Stage (Release v4.49.8): Stage now serves authored command forms as native runtime command-form elements with modeled field descriptors and JSON schema metadata, so required inputs are available before submit instead of falling back to empty command bodies. (part of #236) (part of #237)
Stage (Release v4.49.8): Stage now attaches command routes to native command-form elements as well as action buttons, so form submits and command actions resolve to the same backend route. (part of #236) (part of #237)
Stage (Release v4.49.7): Stage tables now publish selected rows as exact component outputs, including stable ids that contain dots, so named component bindings resolve the selected identity without falling back to a global selection. (part of #236) (part of #237)
Stage (Release v4.49.7): Dependent Stage queries now clear and stay suppressed when bound arguments are null or missing, ignore stale delayed responses after reselection, and avoid fetching unfiltered routes during selection clear. (part of #236) (part of #237)
Stage (Release v4.49.7): Native Stage command forms now fail closed when command field and schema metadata are absent, while still allowing explicitly parameterless commands. (part of #236) (part of #237)
AI (Release v7.16.0): Subscription pool calls stop failover after any native function invocation attempt, including failed or in-flight attempts, so automatic retries cannot repeat uncertain tool effects.
AI (Release v7.16.0): Protected provider credentials that have not been released for use now fail with an actionable reconfiguration error instead of reaching outbound transports as encrypted envelopes.
Stage (Release v4.49.5): Native Stage command forms now keep dirty input values across equivalent scene reloads and layout-only rebinds by stabilizing the Arc command descriptor identity. (part of #236) (part of #237)
Stage (Release v4.49.5): Native Stage command forms now honor explicit empty JSON Schema required lists as optional input and visibly block unsupported object, array, and fractional field-width metadata instead of silently coercing it. (part of #236) (part of #237)
Stage (Release v4.49.4): Authored Scene command actions now receive their Stage command API routes, so native command controls for modeled commands are exposed instead of disabled. (part of #237)
Stage (Release v4.49.4): Stage route metadata now maps modeled command names to the supported runtime command endpoints used by native command forms. (part of #236) (part of #237)
Stage (Release v4.49.3): Native Stage command forms now post valid Arc command values and refresh scoped queries while preserving validation feedback and dirty input through context refreshes. (part of #236) (part of #237)
cli (Release v3.40.2): cratis run now defaults to the Stage 4.49.2 sandbox image, which includes the browser runtime data fix for authored Scene applications. (part of #284)
cli (Release v3.40.2): cratis render now consumes the matching Stage 4.49.2 renderer package while keeping the bundled Screenplay 4.105.0 corpus and query-specification support. (part of #284)
Stage (Release v4.49.2): Stage now serves /stage/scene, /stage/routes and /stage/locales for authored screen compositions that contain guarded screen interactions the runtime can fail closed. (part of #236) (part of #237)
Stage (Release v4.49.2): Guarded screen actions are removed from the runnable Scene payload instead of blocking the whole Stage shell, so the authored screens still load while unsupported guarded behavior stays unavailable. (part of #237)
AI (Release v7.15.1): Restricted checkout workers no longer receive shared repository-cache mounts or cache environment settings in Kubernetes and Docker. Ordinary workers retain their existing cache behavior. Upgrade the Cratis.AI package alongside worker images to close the alternate cached-source access path.
cli (Release v3.40.1): cratis render now emits authored Scene screen compositions from the compiled source documents instead of replacing them with the generated backend command/query fallback surface. (part of #284)
cli (Release v3.40.1): Unsupported guarded screen actions are omitted from the runnable Scene payload and reported as STAGE-SCENE-ACTION-001 warnings, preserving fail-closed behavior while keeping the rest of the authored app surface. (part of #284)
Chronicle (Release v19.35.2): Open alert incident gauges can now be disabled with Cratis__Chronicle__Alerts__IncidentMetricsEnabled=false on every silo, followed by a restart. This stops both gauge production and background incident sampling without disabling alerts or other telemetry; existing installations remain enabled by default. See incident metrics configuration.
Stage (Release v4.49.1): Rendered applications and Stage sessions refuse screens with guarded actions (STAGE-SCENE-ACTION-001) or guarded on click, on double click and on select interactions (STAGE-SCENE-INTERACTION-001) until the Scene runtime can evaluate them, instead of showing an always-visible button that sends no command or dropping the interaction’s branches. The Scene contract and screen-composition planning still carry these constructs, and a Stage host reports the refusal as unsupported instead of failing at startup. (part of #209)
AI (Release v7.14.6): Story investigation workers can check out every scheduled private repository into owner-qualified paths using separate clone-read credentials, without enabling automatic pushes or push-token refresh. Workers fail before launching the agent if any checkout fails or broad GitHub authentication is supplied.
Stage (Release v4.48.3): Read models in the Chronicle Workbench keep updating after the Stage host reconnects to Chronicle. The host’s Chronicle client no longer auto-registers an empty projection set on every connect, which retired the projections Stage had registered, and Stage re-registers its event types, read models and projections on each reconnect. (part of #228)
Stage (Release v4.48.2): A concept declared secret scope namespace or secret scope global renders [Encrypted(EncryptionScope.Namespace)] or [Encrypted(EncryptionScope.Global)] even when the complianceDetails option is off, instead of falling back to subject scope. The option now gates only the free-text reason and details. Concepts without a scope, or with subject scope, render as before. (part of #250)
Stage (Release v4.48.1): Native Stage command forms now wait for registered routes before rendering and keep the Arc CommandForm hook lifecycle stable during route loading. (part of #236) (part of #237)
Stage (Release v4.48.1): Native Stage command forms preserve dirty values while query refreshes update screen data and render manual field geometry with unequal, resizable columns. (part of #236) (part of #237)
Screenplay (Release v4.105.0): Screen composition corpus admission now keeps UI/backend ESM refusals while allowing the canonical screen list-query shapes to bind and execute without weakening authorization or protected refusal outcomes. (part of #536)
AI (Release v7.14.4): Kubernetes workers configured for the batch node pool now prefer nodes already hosting ephemeral runners or managed AI workers across namespaces, rather than spreading them. Other node pools retain their existing placement behavior.
AI (Release v7.14.4): Kubernetes worker pods now carry cluster-autoscaler.kubernetes.io/safe-to-evict: "false" to protect running work from Cluster Autoscaler scale-down independently of PodDisruptionBudgets. Explicit deletion and node failures remain possible.
Arc (Release v22.61.0): A scenario is generated only when every command and event property it needs can be stated from the specification. Scenarios that rely on generated values such as CustomerId.New(), leave a property unset, or expect a null value are now left out with SP0039, so the document binds under Screenplay’s complete-fixture rules instead of failing with SP0056 (#3078)
Arc (Release v22.61.0): Authoring-only scoped documents no longer both import and declare the same read model, or import one they never declare. The import is now decided from the declarations the scoped document actually emits (#3064)
Chronicle (Release v19.35.1): Projection futures read back from storage keep the event store and namespace they belong to, so a projection with nested children no longer fails every event with “missing from the event store ‘[NotSet]’” when its futures are served from another silo (#4656)
AI (Release v7.14.3): The Screenplay model review skill routes Chronicle CLI questions to cratis-chronicle-cli-operations instead of a skill that does not exist (#542)
AI (Release v7.14.3): The Lens skill routes executing a command from backend code to the right skill, and the React page dialog reference points to the step that registers confirmation and busy-indicator dialogs (#542)
AI (Release v7.14.3): The Screenplay specifications skill states that the reference runner executes clock, trigger and capture actions from ESM v6 (#542)
AI (Release v7.14.3): The identity skill states in SKILL.md that a resolved tenant is never an authorization decision (#542)
AI (Release v7.14.3): The release-notes skill reads a repaired release body back before reporting the repair as done (#542)
Arc (Release v22.58.3): The generated Screenplay model keeps identifier and the for destination on a command whose handler returns an event together with a separate response, (TEvent, TResponse), including through Task and ValueTask. Such commands no longer report SP0013/SP0051, and their specifications no longer run as unsupported identity allocation. A response typed as an event source identifier, object, an interface, or a union that can carry an identity still leaves the destination unstated. (#3069)
Arc (Release v22.58.3): A command scenario that only asserts the command was rejected, such as IsValid.ShouldBeFalse() or ShouldHaveValidationErrors(), is now generated as a bare then error that binds and matches the rejection without asserting a message, instead of then error "". (#3046)
Stage (Release v4.41.0): Rendered scoped projections fill the read model’s identifier property from the projection key, so identifier queries and joins that rely on it match Screenplay. (part of #117)
cli (Release v3.37.1): cratis prologue interpret no longer sends capture evidence to a machine-wide model when the project’s cratis-prologue.json sets llm.enabled: false; --no-llm forces local, heuristics-only interpretation; and the command names the provider, destination and where its configuration came from before sending anything, rejecting an endpoint it cannot name (#241)
Arc (Release v22.58.2): Embedded Screenplay generation now preserves the project’s compiler features and interceptor namespaces, including those used by OpenAPI source generators, instead of reporting compilation errors for otherwise valid generated code. Existing SourceCompilation.Create callers remain compatible.
Stage (Release v4.39.0): Unsupported layouts now remain visible as unresolved Scene components instead of silently substituting a default shell. (part of #236)
Screenplay (Release v4.89.1): The @cratis/screenplay-language package builds and publishes again. Its runtime size check now catches a dependency bundled into the runtime, and no longer fails as the language grows
Stage (Release v4.38.1): Rendered command handlers set $context.occurred from the time Arc received the command instead of the clock at handling time, so an event and the policy that authorized it see the same time, and a fixed TimeProvider controls it in tests. A command without a receipt time is refused instead of falling back to the current time. (#238)
Arc (Release v22.58.1): A generated Screenplay specification is left out, reported with SP0039 naming the missing properties, when the Arc scenario asserts only some properties of an event, instead of producing a specification that does not bind. (#3072)
Screenplay (Release v4.87.1): The TypeScript compiler reports the reaction refusal and redelivery diagnostics PLAY0540, PLAY0541, PLAY0542, PLAY0543 and PLAY0544 the same way the C# compiler does, so Monaco and VS Code workspace files show every refusal and redelivery problem the command-line check reports (#521)
Screenplay (Release v4.85.1): Merging a folder, or collapsing it into one document, keeps identical module and feature header comments written in different files, in file order, and a trailing comment on the owning file’s header stays on that line (#517)
Screenplay (Release v4.84.1): PLAY0515 also rejects @sensitive concepts used as a command identifier, an explicit for destination or an event-source identifier, since an event source id can be neither encrypted nor erased (#384)
Screenplay (Release v4.84.1): The concepts guide and the @pii hover no longer claim that Chronicle applies @pii and @sensitive rules automatically (#384)
Screenplay (Release v4.82.5): The event model board shows a specification’s effective typed example values, when redelivered actions and then no events expectations, and keeps showing refusal outcomes (part of #495)
Screenplay (Release v4.82.4): The TypeScript compiler reports PLAY0391 and PLAY0478 like the C# compiler, and Monaco and VS Code no longer drop shared diagnostics such as PLAY0514, PLAY0515 and PLAY0453 (part of #495)
Screenplay (Release v4.82.4): The grammar reference documents not in policies, and the documentation agrees on which inputs count as reachable from navigation and forms (part of #495)
Screenplay (Release v4.82.3): The Invoicing sample demonstrates populating a form from the selected row (part of #495)
Screenplay (Release v4.82.2): The @cratis/screenplay-language package builds and publishes again; its size check had rejected the runtime once timeline read checks and event-first reaction resolution were both included
Arc (Release v22.57.1): The Screenplay generator no longer states validation rules as unconditional when they only run under a condition: inside a named rule set other than default, after an early return or throw in the validator, under When/Unless, or in a DependentRules or Otherwise callback. Such rules are left out and reported with SP0016, for command and concept validators. (#3045)
Screenplay (Release v4.82.1): The event model board shows a specification’s generated values, the values then returns expects, and the read models then asserts are absent, instead of dropping them (part of #495)
Screenplay (Release v4.81.7): When an event and an application trigger share a name, a reaction’s for resolves to the event everywhere: validation, the dependency graph, personal-data checks, rename and find-references, MCP references, and hover and go-to-definition in Monaco and VS Code (#439)
Screenplay (Release v4.81.6): VS Code highlights depends on declarations, and the Invoicing sample shows a declared module dependency (part of #495)
Screenplay (Release v4.81.5): The Monaco editor colours a document’s numbers preamble as a keyword instead of as a plain identifier (part of #495)
Screenplay (Release v4.81.5): The grammar, AST authoring and workspace transport references describe exact numeric mode: the numbers preamble, per-file mode agreement, bounded decimals and the canonical ExactNumber form (part of #495)
Chronicle (Release v19.34.2): A quarantined observer now stays quarantined until an operator clears it or it receives a fresh subscription. Before, a watchdog check, a catch-up or replay job finishing, or the event store subscription check could silently resume it. Completed work still records its progress, so clearing the quarantine resumes from where that work stopped, and for a subscribed observer it also resumes paused jobs and retries failed partitions. Ending quarantine lists exactly what ends a quarantine. (#4440)
Stage (Release v4.32.0): Reaction and type descriptions containing <, >, & or line breaks no longer produce broken XML documentation or code. (#178)
Screenplay (Release v4.81.4): The MCP server’s initialization guidance and the open-workspace tool description now say how the server finds a model: nested .play files in the client’s project root, then Source or src, then a new Screenplay folder, and Documents/Screenplay in the home folder when there is no client root (part of #495)
Screenplay (Release v4.81.3): PLAY0515 now rejects personal-data values typed directly in a reaction’s trigger clause as reaction destinations, for registered and undeclared triggers, in both compilers and the editors (#442)
cli (Release v3.33.0): Shell completion no longer lists every subcommand of a command group twice, and no longer offers the global output options for cratis screenplay mcp.
Screenplay (Release v4.81.2): The MCP event model board keeps its Board and Map controls and a usable dependency map when the board cannot be read or drawn, and a failure in one view no longer takes down the other (#477)
Screenplay (Release v4.81.2): A selected dependency map node or edge, and its details, stay selected across edit refreshes in VS Code while the item still exists, including while a filter hides it (#478)
Screenplay (Release v4.81.1): Printing a Screenplay document keeps large integers and small fractions as written, instead of switching to scientific notation, in event payloads and stream routes (#476)
Stage (Release v4.30.0): Stage status reports the runtime engine actually selected, including --engine= overrides and the default eventmodel engine; it previously reported an engine only when the environment variable set it to semantic. (part of #23)
Stage (Release v4.28.0): Rendered command handlers append each produced event to the event source named by its for, instead of always using the command identifier, and the rendered specifications check each event on that same event source. Productions without for are unchanged. (#187)
Chronicle (Release v19.34.1): Reactors and other observers with tag, event source type or event stream type filters no longer receive events their filters exclude when they catch up, replay or recover a failed partition. Events appended before the observer registered are now filtered the same way as events delivered live, and the observer moves past excluded events without counting them as handled (#4529)
Screenplay.CritterStack (Release v0.26.0): A command, its aggregate, events, read model and endpoints sharing one flat feature namespace are split into slices by artifact instead of failing generation with GEN0007 (#81)
Screenplay.CritterStack (Release v0.25.0): Enum concepts no longer capture a same-named enum that was rejected, and enum values the Screenplay compiler cannot parse are reported instead of generated
Screenplay.CritterStack (Release v0.25.0): Types without a concept, HEAD and OPTIONS endpoint effects, query identifiers and timeout triggers are kept in generated models
Screenplay.CritterStack (Release v0.25.0): Fetched streams are linked only to targets that can be proven
Arc (Release v22.55.0): A generated query states by <parameter> only when the parameter matches a property of the read model it returns; otherwise the parameter is a filter. (#3039)
Screenplay (Release v4.79.0): A target repeated on a module or feature that is written twice in one document is now reported as a repeat (PLAY0555), as it is across files, and the unknown-directive message lists depends on. (part of #416)
cli (Release v3.30.1): cratis screenplay mcp started with --project-root or --project-root-env, as cratis ai install registers it, or with a .cratis/ai.json that sets no model root, keeps serving a folder that already holds Screenplay workspace state, so applied identities and interrupted-write recovery are no longer lost when the model lives in a nested folder. When several folders between the project and the model hold state, the one nearest the project is used and the others are reported on standard error; an interrupted write in another of those folders, or workspace metadata that is a link or has the wrong file type, stops startup with a message naming the folder. (#268)
Screenplay (Release v4.76.1): module completion no longer offers layout and dialog; it offers screen template and dialog template, which the language has.
cli (Release v3.30.0): In the embedded MCP server, moving a feature or slice earlier among its siblings in a typed edit is no longer refused, and merging a folder model back into one document keeps comments written on authorize statements.
Screenplay (Release v4.75.0): The Monaco tokenizer no longer throws on a generated property written without identifier.
Arc (Release v22.52.0): A validation message no longer attaches to the preceding rule when the validator it follows cannot be read. (part of #2887)
Arc (Release v22.52.0): The embedded event model board shows event tag values instead of their syntax, and does not ask for generated values as command inputs. (part of #2887)
Chronicle (Release v19.33.4): A rejected reactor or reducer registration no longer breaks later calls on the same connection. Before, a keep-alive or another call sent while the failed stream was closing could fail with “Reading is already in progress”. (#4537)
Chronicle (Release v19.33.4): A rejected reactor or reducer registration now ends the call with an error that the client sees. Before, the call could end as successful while the client kept waiting. (#4537)
Chronicle (Release v19.33.4): A reactor or reducer registration with a missing event type is rejected with a clear error instead of failing inside the kernel. (#4537)
Screenplay (Release v4.73.3): The Monaco and VS Code editors now treat readmodel as a construct inside a slice, and highlight, complete and document every construct the language has (reducer, dialog, form, contribute, theme, ui, behavior, specification and more).
Screenplay (Release v4.73.2): Merging a folder model back into one document no longer drops comments written on authorize statements. (#412)
Screenplay (Release v4.73.1): The Screenplay MCP server again keeps an existing workspace’s identities and interrupted-write recovery when it picks its model folder itself (no explicit path and no configured root) and the model lives in a nested folder such as Models/ or Source/. If the offered folder, or a folder between it and the model, already holds .screenplay state, that folder is used, as before 4.67. (#451)
Screenplay (Release v4.73.1): When more than one of those folders holds .screenplay state, the one nearest the offered folder is used and open-workspace reports the competing folders, including when opening fails; nothing is migrated. If you created state in the model folder with 4.67 or later and want to keep using it, open that folder explicitly. An interrupted write recorded in a competing folder blocks reading and writing until you open that folder and recover it. (#451)
Chronicle (Release v19.33.3): Replaying an observer while it is finishing a catch-up no longer drops the replay or returns an empty job id. The replay waits for the hand-over to complete, then starts, and Replay returns the id of the replay job that was actually started. This also covers automatic replays after a projection, reducer, reactor or webhook definition changes. (#4514)
Chronicle (Release v19.33.3): Resuming a stopped replay job no longer stalls until the call times out. A resume from outside the observer waits until the observer has entered replay before it starts processing. It is refused while the observer is disconnected or quarantined, so the job stays stopped. (#4514)
Chronicle (Release v19.33.3): Replay on projections, reactors and reducers documents that it returns no job id when the observer cannot replay from its current state (disconnected or quarantined). (#4514)
Screenplay (Release v4.72.0): The MCP server merges a workspace’s files in file-path order, matching folder compilation on disk; it previously merged them in an order derived from document identifiers. (#434)
Chronicle (Release v19.33.2): Event content with unsigned 64-bit integers above long.MaxValue (for example ulong.MaxValue) can be appended, read back, revised and redacted with MongoDB storage. This includes values in arrays and named primitive types. Before, the append failed. (#4588)
Chronicle (Release v19.33.2): MongoDB read models store and read unsigned 64-bit values above long.MaxValue without wrapping them to negative numbers. Values written by earlier versions still read back correctly. (#4588)
Chronicle (Release v19.33.2): SQL storage keeps unsigned 64-bit event content exact instead of converting it through a floating-point value. (#4588)
Chronicle (Release v19.33.1): Global seeds registered with SeedEvents are now applied to namespaces created afterwards, for example a tenant namespace ensured after startup. Namespaces created before this release are not seeded retroactively. (#4547)
Chronicle (Release v19.33.1): The in-process test host in Cratis.Chronicle.XUnit.Integration registers the kernel’s system event types at startup and after every reset, so tests that create additional namespaces work against this release. (part of #4547)
Chronicle (Release v19.33.0): Clients that encode contracts with proto3 semantics (TypeScript, Go, Kotlin, Elixir, Python) can register reactors that are not replayable and webhooks that are not replayable or not active. ReactorDefinition gains IsNotReplayable, and WebhookDefinition gains IsNotReplayable and IsInactive. These plain booleans default to false, and a true value turns the setting off even when IsReplayable or IsActive is omitted. Existing clients and the existing fields keep working unchanged. (#4394)
Chronicle (Release v19.33.0): ObserverInformation.IsReplayable is now always sent, so proto3 clients read the correct value from GetObservers instead of false for every observer. (#4394)
Screenplay (Release v4.70.0): Moving a feature or slice earlier among its siblings in a typed workspace edit now prints it at its new position instead of after the last sibling, so the move is no longer refused. (part of #413)
Screenplay (Release v4.69.1): Report undeclared events in projection removals and capture appends, and missing read-model properties in projection mappings, in both compilers. (#378)
Screenplay (Release v4.69.1): Reject @pii concepts used as event-source identifiers or typed command and reaction destinations, with guidance to use a surrogate identifier. (part of #384)
Screenplay (Release v4.69.0): The imports and folders documentation now says that the MCP App looks for another importing root only when the folder has no application.play, and that VS Code compiles only what an importing document imports when no application.play sits above it. (part of #413)
Screenplay (Release v4.68.4): Include reactions in the MCP event model board’s added and removed summaries and current and proposed counts. (#379)
cli (Release v3.28.5): cratis ai install and cratis ai update now install scripts with their execute bit, so hook scripts such as .cratis/ai/hooks/scripts/cratis-quality-gate.sh can be run directly. A file is executable when the corpus ships it as executable or it starts with a shebang; execute is granted only to those who can already read it, and update repairs existing installations and removes execute bits from managed files that are not scripts. When an installed script must become executable but another user owns it, or the file system refuses every mode change on it, the update stops before changing any file and says so; scripts the file system otherwise leaves non-executable are listed under warnings. (#251)
cli (Release v3.28.4): Screenplay validation and MCP use Screenplay 4.66.1, and cratis version displays the bundled compiler version in text and JSON output. (#242)
cli (Release v3.28.4): cratis screenplay validate <file> follows the root file’s imports, counts imported documents and reports diagnostics against their source files. (#244)
AuthProxy (Release v2.30.5): Unicode service hosts are canonicalized the same way as incoming internationalized host names, including decomposed, fullwidth and other compatibility forms. Declarations whose mapping would turn into a port or other authority delimiter are rejected at startup, and plain ASCII host names parse as before. (#173)
AuthProxy (Release v2.30.5): Activity-timeout documentation states the supported range of 1 to 2,147,483,647 milliseconds. (#173)
Screenplay (Release v4.68.3): Draw the MCP App and VS Code event model boards in authored declaration and import order, respecting final file placement and alphabetical glob matches without changing executable model bytes or identities. (#411)
Orleans (Release v1.15.3): Trace context now propagates across grain calls in silos hosted with AddCratisOrleans, while tenant context remains separate from activity baggage. (#47)
Screenplay.Generation (Release v0.18.1): Preserve compiler warning codes, messages, severity, and source positions in generated Screenplay definitions, including successful generation. (#64)
Screenplay (Release v4.68.2): The reactions, contexts and MCP reference pages describe how ESM v7 generated values and command responses behave. (#420)
Chronicle.Elixir (Release v3.10.2): Append constraint violations use the messages declared on the client’s configured event types, including batch and transactional appends. (#94)
Chronicle.Elixir (Release v3.10.2): Connection checks tolerate delayed trust-store loading and failed-session startup under load. (#70)
Screenplay (Release v4.68.1): The event model board shows the values each specification sets and asserts, its error messages and its caller, using the updated board package. (#409)
Chronicle (Release v19.32.4): Waiting for an append to complete no longer waits for, or reports failed partitions from, internal kernel reactors such as pattern capture that are not subscribed in the target namespace. Projections, webhooks, event-store subscriptions and client observers remain included in completion waits, even before subscribing or while disconnected. (#4492)
Components (Release v4.25.2): Pinching on a trackpad or touch device no longer falls through to the browser’s own page zoom when the gesture event carries no pointer coordinates, as can happen with Safari gesture events. Canvas now falls back to the last pointer position and then the canvas centre, so the pinch zooms the canvas instead (Cratis/StudioIssues#476)
Arc (Release v22.50.7): An application whose authentication or authorization handlers are registered as scoped no longer fails at startup when the discovery endpoints require authentication, which is the default outside Development, and services that only support asynchronous disposal are disposed correctly during that startup check (#3032)
Arc (Release v22.50.6): Paged MongoDB query results no longer fail when the query pipeline materializes them for read-model interception. (#2966)
Arc (Release v22.50.6): Route parameter names containing regex metacharacters are treated literally by GET and QUERY requests. (#3014)
Arc (Release v22.50.6): Generated command properties such as Origin no longer collide with the command runtime’s backing fields. (#2978)
Arc (Release v22.50.6): Core documentation now describes discovery as anonymous only in Development by default, with authentication required elsewhere. (#2965)
Arc (Release v22.50.6): Chronicle command examples now use nullable projected-state parameters and handle missing state explicitly without triggering ARC0006. (#2940)
Chronicle (Release v19.32.3): An observer no longer stays behind the tail when an event is appended while its catch-up job is finishing. A new catch-up starts for that event instead of waiting for the finishing job, and overlapping catch-ups share a single job. (#4548)
Chronicle (Release v19.32.3): Observers created without stored state no longer share their catching-up, replaying and in-flight partition sets, so one observer’s catch-up no longer makes the others drop live events. (#4558)
Chronicle (Release v19.32.3): A reducer batch that fails part-way is retried from the start of the batch, so events folded before the failure are no longer skipped. (#4540)
Chronicle (Release v19.32.3): Webhooks in event stores other than the System store now keep their authorization and their updates to event types, target URL and headers, and adding, updating or removing a webhook now fails when one of its events could not be appended. (#4567)
Chronicle (Release v19.32.3): MongoDB: a projection write that arrives while a catch-up’s final bulk flush is in progress is now written instead of dropped, so the read model no longer stays behind an observer that reports the event as handled. (#4598)
Components (Release v4.25.1): CommandDialog no longer replaces a render-function child with its mapped result, so a render-prop component such as a paged-results helper inside a command dialog no longer throws children is not a function (#396)
AuthProxy (Release v2.30.3): Canonical OIDC identities now resolve correctly during sign-in notification, subject linking, and legacy invitation completion, using the authenticated provider or session scheme instead of the identity’s authentication type. (#122)
AuthProxy (Release v2.30.2): Replacement invitation pages can now display HTML-encoded invited and asserted email addresses during validated invitation selection and completion, helping users identify a wrong-account sign-in without exposing addresses outside the invitation flow. (#133)
AI (Release v7.11.1): The quality gate checks the repository’s own projects instead of the AI corpus packages that cratis ai install placed in it, runs a gate in every package a change touches, and never reports success when a package it should have checked was skipped (#487)
Chronicle (Release v19.32.2): Global encrypted values can provision their keys with MongoDB; the reserved global key store no longer produces an invalid MongoDB database name. (#4549)
Chronicle (Release v19.32.2): Protected numbers and booleans are released with the type their schema declares instead of as JSON strings, including inside arrays, for erased values and for enums stored by name. (#4550)
Chronicle (Release v19.32.2): Compliance metadata declared on a dictionary’s value schema (additionalProperties) is now applied to every dictionary value: values are encrypted, erased with their subject and refused after erasure. (#4551)
Chronicle (Release v19.32.2): Array elements that are themselves classified collections are encrypted, released and erased as a whole, while objects with declared properties keep per-member protection, so data already stored that way still releases. (#4552)
Chronicle (Release v19.32.2): Event-type migrations transform plaintext instead of ciphertext, so split, combine and map work on [PII] values, and each target generation is protected for the original subject. (#4456)
Chronicle (Release v19.32.2): Revised event content and the revision request are protected with the original event’s subject before they are stored. (#4525)
Chronicle (Release v19.32.2): Projection folds, immediate projections and GetInstanceById keep the subject each protected value was written under, so values whose subject differs from the read-model key are released correctly. (#4561)
Screenplay (Release v4.66.2): The event model board shows each specification’s command once instead of twice. (#408)
Chronicle (Release v19.32.1): MongoDB: removing a child read model through a join (RemovedWithJoin) now matches child identifiers named id or Id, including children in nested collections, and skips documents where the collection is missing or not an array. SQL removes children in nested collections the same way. (#4538)
Chronicle (Release v19.32.1): Projection Preview keeps the properties of a read-model schema it infers from registered events, including arrays of objects, references and nullable anyOf/allOf values. The inferred schema saved with the projection now contains them too. (#4539)
Chronicle (Release v19.32.1): Projections that subscribe to all events alongside explicit from declarations now see every event in replay, read-model snapshot history and Preview, also when the all-events subscription uses a custom key. (#4562)
Chronicle (Release v19.32.1): Registering a projection with an open-schema child joined by an explicit identifier no longer fails with a NullReferenceException. (#4564)
Screenplay (Release v4.66.1): Compiler diagnostics, editor hints, the event-model board, MCP tool descriptions and the documentation no longer promise a future executable model version for generated values and responses, operations and systems, event sources and streams, or exact numbers. They now say these constructs are not admitted by any supported executable model version yet; binding still refuses them with PLAY0268. (part of #309)
Chronicle.Go (Release v0.4.0): A strict scenario now rejects a root-level join-removal event as unsubscribed, matching the kernel, instead of refusing the whole projection (part of #38)
release-action (Release v1.4.2): A run that loses the version race to a concurrent run now fails its post step instead of reporting success. When the release for its tag already exists for another commit, the step fails naming that commit, so jobs that need the release job do not publish under a version that belongs to someone else; re-running the run releases it under the next version. See Concurrent runs (#178)
AI (Release v7.9.2): The Claude Code hooks run each guard script through bash, so the write, store-mutation and PR-body guards and the quality gate keep enforcing when an install or checkout has lost the scripts’ execute bit (#480)
AI (Release v7.9.2): The store-mutation guard describes cratis chronicle jobs resume as resuming a stopped job; a failed job cannot be resumed (#466)
AI (Release v7.9.2): The PR-body guard checks the pull request a command actually edits: it honours a command-local GH_REPO, resolves a PR URL, --repo or GH_REPO target before an unknown working directory, keeps checking later commands on the same line, and lets gh pick the repository when none is named (#472)
cli (Release v3.27.2): cratis ai install and cratis ai update keep an existing MCP configuration’s own indentation, nesting and line endings when they add or remove a server, so .vscode/mcp.json and the other JSON and Codex TOML configurations no longer get whitespace-only lines, and removing a server gives back the file as it was (#248)
AI (Release v7.9.1): Claude subscriptions authenticated with a long-lived claude setup-token token now report their 5-hour and weekly windows. The usage endpoint refuses those tokens with 403 because they lack the user:profile scope. Capacity is now read from the rate limit headers of a one-token Messages request, including when the subscription is already over its limit.
AI (Release v7.8.0): Claude subscription limit messages such as “You’ve hit your weekly limit” are recognized as rate limits, so a pool fails over to another member instead of failing the work.
AI (Release v7.8.0): A provider that hits a limit is parked until the reset the limit states, not for a flat hour, so it is no longer retried hourly while its weekly limit lasts.
AI (Release v7.8.0): Pool completions skip members whose capacity says they cannot start work, and AIProviderPoolDispatcher skips rate-limited members.
AI (Release v7.7.0): Translation has one meaning across rules, skills and prompts: outside data becomes your own facts. (#490)
AI (Release v7.7.0): The Screenplay skills no longer say that reacti
Fundamentals (Release v7.22.8): Nested derived types — direct properties, arrays, and collections or dictionaries whose element type is a derived-type family — are now written with their type identifier. (#1149)
Fundamentals (Release v7.22.7): Serializing and deserializing objects with null fields, null array elements and null map values no longer throws, and explicit nulls are preserved. (#1148)
Fundamentals (Release v7.22.6): OpenTelemetry SDK disablement now applies to tracing, metrics, and logging added after WithCratis, including when its configuration differs from the host configuration. (#1147)
Fundamentals (Release v7.22.6): HTTP OTLP endpoints now preserve query strings when appending trace, metric, and log paths. (#1147)
Chronicle (Release v19.31.11): A client whose observer registration failed about 44 times in a row (for example during a long kernel outage) no longer gets stuck throwing OverflowException: TimeSpan overflowed on every retry. Registration now backs off up to its one-minute cap and recovers once the kernel is reachable again.
Chronicle (Release v19.31.11): In a multi-silo kernel, a Cratis exception thrown across silos (such as ClientIsNotConnected during reducer registration) now reaches the caller with its type and message. Before, the response failed to serialize (Serialization and deserialization of 'System.Reflection.MethodBase' instances is not supported) and the caller hung until it timed out.
Screenplay (Release v4.63.2): The Screenplay MCP server reads the folders a host shares with it from the roots array that the MCP schema defines. It expected a different field, so with Claude Desktop the startup handshake failed, Claude restarted the server between calls, and every call after open-workspace failed with “Open a workspace first” or a rejected fallback folder.
Screenplay (Release v4.63.2): A failure while handling a notification is now written to the server’s log instead of being sent back as an error with a null id, which made hosts drop the connection. The session stays open.
Fundamentals (Release v7.22.5): JavaScript DateOnly, TimeOnly and TimeSpan now reject out-of-range values such as 2024-13-45, 25:99:00 and 00:60:00 as C# does, and TimeOnly keeps the full seven-digit fraction so map keys that differ below a millisecond no longer collide (#1160)
cli (Release v3.53.0): The CLI-RENDER-015 refusal of navigation contributions that declare id, icon, presentation, group or destination outlet|dialog|external: Stage 4.73.0 honours them, so cratis render now renders them and writes them into the scene. (part of #284)
Arc (Release v22.65.3): IIdentitySource and IdentitySource, CommandScenario.Generate(...) and QueryScenario.Generate(...), and the two-argument EventSourceValuesProvider constructor are removed. They were added in v22.64.0, but nothing could use them: an unnamed queue of Guid values can’t pin named generated values of other types, handlers that create ids with New() or Guid.NewGuid() bypass it, and no Cratis code depends on it. Named, typed generated values will replace them. (#3125)
Arc.Go (Release v0.1.1): Upgrade golang.org/x/net to v0.60.0 to fix GO-2026-6603, GO-2026-6610, GO-2026-6611, GO-2026-6612 and GO-2026-6617 (#79)
Arc.Go (Release v0.1.1): Build and test with the latest Go patch release, which fixes the same issues in the standard library (#79)
Chronicle.Go (Release v0.9.1): Upgrade golang.org/x/net to v0.60.0 to fix GO-2026-6603, GO-2026-6610, GO-2026-6611, GO-2026-6612 and GO-2026-6617 (#100)
Stage (Release v4.31.0): A claim compared with a Uuid matches only the Uuid’s canonical lower-case text. A query argument that reaches the policy as an empty, upper-case or otherwise non-canonical string no longer matches a claim, so a caller holding an empty claim value is denied. (part of #57)
AuthProxy (Release v2.30.4): Access tokens cached for a backend are no longer reused after its address changes during a configuration reload, even when the session and audience are unchanged. (#177)
Arc (Release v22.74.0): ProtectedIdentityAnnotations (in Cratis.Arc.Screenplay.Emission) is obsolete; the generator no longer uses it, and it will be removed in a future major version. (#3096)
Screenplay (Release v4.100.0): @pii, @sensitive and sensitive (including sensitive reason) still compile, with an information diagnostic and a repair for the line or the whole document that keeps every reason (part of #557)
Screenplay (Release v4.99.0): An opaque where guard on on click, on double click or on select. A guard that reads as an item condition reports a warning with a repair that rewrites it as a when branch. Other guards report information. where on event, change and application triggers is unchanged (#447)
Chronicle.Go (Release v0.9.0): readmodels.DecisionProtectedModel and readmodels.DecisionProtectionMetadata are no longer returned by decision-read admission and will be removed in a future release. (part of #34)
