@cratis/pi 7.92.0 → 7.94.0

package/package/corpus/harnesses/copilot/instructions/discoverability.instructions.md

@@ -0,0 +1,34 @@
+---
+applyTo: "**/Documentation/**/*.md,**/Documentation/**/*.mdx,**/src/pages/**/*.astro,**/src/pages/**/*.md,**/src/pages/**/*.mdx,**/src/pages/**/*.html,**/src/content/**/*.md,**/src/content/**/*.mdx"
+paths:
+  - "**/Documentation/**/*.md"
+  - "**/Documentation/**/*.mdx"
+  - "**/src/pages/**/*.astro"
+  - "**/src/pages/**/*.md"
+  - "**/src/pages/**/*.mdx"
+  - "**/src/pages/**/*.html"
+  - "**/src/content/**/*.md"
+  - "**/src/content/**/*.mdx"
+---
+<!-- cratis-ai: generated Copilot instructions. Do not edit; rules/ is the source. -->
+
+# Writing content that people and assistants can find
+
+Readability comes first. If a change for search engines or AI assistants makes a page harder to read, drop the change. Voice, structure and examples stay with [writing-cratis-docs.md](./writing-cratis-docs.instructions.md), [editing-cratis-docs.md](./editing-cratis-docs.instructions.md) and [documentation-structure-and-formatting.md](./documentation-structure-and-formatting.instructions.md); this rule adds only what they do not cover. Before publishing a page, post or package, use **cratis-discoverability**.
+
+## Every page, post and README
+
+- **Define first, where a definition belongs.** Landing pages, product index pages, glossary entries, READMEs and package descriptions open with one self-contained sentence: "X is a <category> for <audience> that <does>."
+- **Docs tutorials, getting-started pages and explanations follow [writing-cratis-docs.md](./writing-cratis-docs.instructions.md)**: scenario first, pain before relief. Their answer-first, self-contained definition goes in the frontmatter `description`, which serves search and AI. Where it reads naturally, one definition sentence may follow the opening scenario. writing-cratis-docs wins on voice and structure.
+- **Title and description are written by hand.** Title with the distinguishing term first: 50-60 characters for blog and landing pages, 20-60 for docs and reference pages; a README H1 that is the product name is fine. Description is one sentence of 60-160 characters, never over 160, and not a copy of the title or of another page's description.
+- **Name things one way.** The first mention is the full name ("Cratis Chronicle"), later mentions may shorten it. Use the canonical names in the **cratis-discoverability** entity reference, and do not call the platform "Cratis.io".
+- **Links name their destination.** Link text says what is behind it. Outside the docs site, link docs with the absolute canonical host `https://www.cratis.io/...`, never the bare `cratis.io`.
+- **Images carry alt text.** Describe the content. Use an empty `alt=""` only for decoration.
+- **No keyword stuffing, no filler for length, no text hidden from readers.** A page is done when it is complete.
+
+## Sites and packages
+
+- Public pages need a canonical link, one `<h1>`, Open Graph tags, valid JSON-LD that describes visible content, a sitemap entry and a `robots.txt` that allows crawling. Add no new `HowTo` or `FAQPage` markup; keep the visible Q&A.
+- `llms.txt` is an optional index. Never claim it improves ranking. See **cratis-llm-friendly-documentation**.
+- Package metadata (`Description`, `PackageProjectUrl`, `PackageTags`, npm `description`, `homepage`, `keywords`) and the README opener use the same definition sentence, and the project URL points at the docs page `https://www.cratis.io/<product>/`.
+- State only facts the repository supports: versions, licenses, limits. The claim gate in `BRAND.md`, `MESSAGING.md` and `SITE.md` still applies.

package/package/corpus/hooks/scripts/cratis-patterns.json

@@ -87,6 +87,30 @@
             "paths": ["**/*.ts", "**/*.tsx"],
             "exclude_paths": ["**/node_modules/**", "**/dist/**", "**/wwwroot/**", "**/obj/**", "**/bin/**"],
             "message": "Cratis Components 4 has no PrimeReact underneath — a `primereact/dialog` import is a leftover from Components 3. Use `CommandDialog` from `@cratis/components/CommandDialog` or `Dialog` from `@cratis/components/Dialogs`."
+        },
+        {
+            "id": "cratis-apex-docs-link",
+            "rule": "discoverability.md — canonical links",
+            "pattern": "https?://cratis\\.io([/)\"' <]|$)",
+            "paths": ["**/*.md", "**/*.mdx", "**/*.html", "**/*.astro"],
+            "exclude_paths": ["**/node_modules/**", "**/dist/**", "**/obj/**", "**/bin/**", "**/.ai-work/**"],
+            "message": "Discoverability (advisory): the docs host is `https://www.cratis.io`. Link the canonical host, not the bare `cratis.io`."
+        },
+        {
+            "id": "cratis-empty-image-alt",
+            "rule": "discoverability.md — images carry alt text",
+            "pattern": "!\\[\\]\\(",
+            "paths": ["**/*.md", "**/*.mdx"],
+            "exclude_paths": ["**/node_modules/**", "**/dist/**", "**/obj/**", "**/bin/**", "**/.ai-work/**"],
+            "message": "Discoverability (advisory): an image with empty alt text. Describe the content, or keep it empty only when the image is purely decorative."
+        },
+        {
+            "id": "cratis-package-url-github-only",
+            "rule": "discoverability.md — package metadata",
+            "pattern": "<PackageProjectUrl>[[:space:]]*https?://github\\.com",
+            "paths": ["**/*.csproj", "**/*.props"],
+            "exclude_paths": ["**/node_modules/**", "**/obj/**", "**/bin/**"],
+            "message": "Discoverability (advisory): `PackageProjectUrl` should point at the product's docs page `https://www.cratis.io/<product>/`, not only at GitHub."
         }
     ]
 }

package/package/corpus/prompts/pre-publish-check.prompt.md

@@ -0,0 +1,26 @@
+---
+agent: agent
+description: "Run the discoverability check on content about to be published."
+---
+
+# Pre-publish check
+
+Run the discoverability check on what is about to be published: a docs page, blog
+post, landing page, README or package metadata. Follow
+`.cratis/ai/rules/discoverability.md` and invoke **cratis-discoverability**.
+
+## Identify the content
+
+Find the files in the change, the content type of each, and the owning source (never
+a synced copy). Ask only when the content type is unclear.
+
+## Check and fix
+
+Apply the skill's checks for each content type to the draft: opening definition,
+title and description, canonical names, canonical `https://www.cratis.io/...` links,
+alt text and, for sites and packages, the structured data and metadata. Make the
+fixes in the owning files. Where a fix would hurt readability, keep the text and
+report it. For a built site, run the skill's checker on the build output.
+
+Report what changed, what was left alone and why, and any check that could not run.
+Publishing, merging and releasing stay with a person.

package/package/corpus/rules/discoverability.md

@@ -0,0 +1,33 @@
+---
+applyTo: "**/Documentation/**/*.md,**/Documentation/**/*.mdx,**/src/pages/**/*.astro,**/src/pages/**/*.md,**/src/pages/**/*.mdx,**/src/pages/**/*.html,**/src/content/**/*.md,**/src/content/**/*.mdx"
+paths:
+  - "**/Documentation/**/*.md"
+  - "**/Documentation/**/*.mdx"
+  - "**/src/pages/**/*.astro"
+  - "**/src/pages/**/*.md"
+  - "**/src/pages/**/*.mdx"
+  - "**/src/pages/**/*.html"
+  - "**/src/content/**/*.md"
+  - "**/src/content/**/*.mdx"
+---
+
+# Writing content that people and assistants can find
+
+Readability comes first. If a change for search engines or AI assistants makes a page harder to read, drop the change. Voice, structure and examples stay with [writing-cratis-docs.md](./writing-cratis-docs.md), [editing-cratis-docs.md](./editing-cratis-docs.md) and [documentation-structure-and-formatting.md](./documentation-structure-and-formatting.md); this rule adds only what they do not cover. Before publishing a page, post or package, use **cratis-discoverability**.
+
+## Every page, post and README
+
+- **Define first, where a definition belongs.** Landing pages, product index pages, glossary entries, READMEs and package descriptions open with one self-contained sentence: "X is a <category> for <audience> that <does>."
+- **Docs tutorials, getting-started pages and explanations follow [writing-cratis-docs.md](./writing-cratis-docs.md)**: scenario first, pain before relief. Their answer-first, self-contained definition goes in the frontmatter `description`, which serves search and AI. Where it reads naturally, one definition sentence may follow the opening scenario. writing-cratis-docs wins on voice and structure.
+- **Title and description are written by hand.** Title with the distinguishing term first: 50-60 characters for blog and landing pages, 20-60 for docs and reference pages; a README H1 that is the product name is fine. Description is one sentence of 60-160 characters, never over 160, and not a copy of the title or of another page's description.
+- **Name things one way.** The first mention is the full name ("Cratis Chronicle"), later mentions may shorten it. Use the canonical names in the **cratis-discoverability** entity reference, and do not call the platform "Cratis.io".
+- **Links name their destination.** Link text says what is behind it. Outside the docs site, link docs with the absolute canonical host `https://www.cratis.io/...`, never the bare `cratis.io`.
+- **Images carry alt text.** Describe the content. Use an empty `alt=""` only for decoration.
+- **No keyword stuffing, no filler for length, no text hidden from readers.** A page is done when it is complete.
+
+## Sites and packages
+
+- Public pages need a canonical link, one `<h1>`, Open Graph tags, valid JSON-LD that describes visible content, a sitemap entry and a `robots.txt` that allows crawling. Add no new `HowTo` or `FAQPage` markup; keep the visible Q&A.
+- `llms.txt` is an optional index. Never claim it improves ranking. See **cratis-llm-friendly-documentation**.
+- Package metadata (`Description`, `PackageProjectUrl`, `PackageTags`, npm `description`, `homepage`, `keywords`) and the README opener use the same definition sentence, and the project URL points at the docs page `https://www.cratis.io/<product>/`.
+- State only facts the repository supports: versions, licenses, limits. The claim gate in `BRAND.md`, `MESSAGING.md` and `SITE.md` still applies.

package/package/corpus/rules/general.md

@@ -131,6 +131,7 @@ A claim is only as good as the signal behind it — a build result, a test run,
 | C# / TypeScript style and code-quality principles | `csharp.md`, `typescript.md`, `code-quality.md`, `code-quality.csharp.md`, `code-quality.typescript.md` |
 | Kotlin / Java / Elixir style; Orleans grains; reactors; GitHub Actions workflows | `kotlin.md`, `java.md`, `elixir.md`, `orleans.md`, `reactors.md`, `github-actions.md` |
 | Documentation pages (`Documentation/`): structure, voice, examples, editing | `documentation.md`, `documentation-structure-and-formatting.md`, `writing-cratis-docs.md`, `editing-cratis-docs.md`, `writing-correct-examples.md` |
+| Findability of published pages, READMEs and package metadata | `discoverability.md` |
 | Go style, source and module files | `go.md`; framework contributors also read `go-engineering.md`; product APIs use `cratis-chronicle-client-go`, `cratis-arc-go` and `cratis-fundamentals-concept-go` |
 | Service lifetimes — why anything taking a scoped dependency is scoped or transient, never a singleton | `csharp.md` |
 | React + Arc + Cratis Components + MVVM + dialogs | `react.md`, `components.md`, `dialogs.md` |

package/package/corpus/skills/cratis-discoverability/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) Cratis. All rights reserved.
+Licensed under the MIT license. See LICENSE file in the project root for full license information.

package/package/corpus/skills/cratis-discoverability/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: cratis-discoverability
+description: Run the pre-publish check that makes Cratis content easy to find in search and AI answers without making it harder to read - a docs page, blog post, landing page, README or package metadata (title, description, opening definition, canonical links, entity names, alt text, structured data). Use when about to publish or review content for discoverability, SEO, AEO or GEO, or when writing package descriptions and README openers. Not for page voice and structure (cratis-documentation-writing), llms.txt design (cratis-llm-friendly-documentation), distribution plans (cratis-developer-marketing) or length decisions (cratis-content-length).
+license: MIT
+---
+
+# Discoverability before you publish
+
+Discoverability is a property of good content: a clear definition, an honest title, one name per
+thing and working links. The always-on rule is [discoverability.md](../../rules/discoverability.md);
+this skill is the procedure to run on the finished draft. If a fix makes the page worse to read,
+drop the fix and say so.
+
+## Procedure
+
+1. Name the content type: docs page, blog post, landing page, README or package metadata.
+2. Name the reader's one job and, for docs, the page type (tutorial, how-to, reference, explanation).
+3. Apply the checks for that type below. Fix the draft; do not annotate it.
+4. For a built site, run the checker and fix errors; warnings are judgment calls to report.
+5. Report what was changed, what was left alone and why.
+
+Read `references/page-checklist.md` for the full per-type checklist and the field lengths.
+
+## Checks by content type
+
+- **Docs page.** The `description` is written by hand as one self-contained
+  definition or outcome sentence. Tutorials, getting-started pages and explanations follow
+  `writing-cratis-docs` (scenario first); the definition lives in the `description`, and one
+  definition sentence may follow the opening scenario where it reads naturally. `writing-cratis-docs`
+  wins on voice and structure. Product index pages open with the definition sentence.
+  Reference pages stay terse: title is the exact name plus its product, no question headings, no
+  intro. Titles are unique across the site and name the product ("Chronicle projections").
+- **Blog post.** The title states the topic in the words a reader would search. The intro gives the
+  conclusion in two sentences. Show the named author and date, add `lastUpdated` only for real
+  changes, link the owning docs pages with `https://www.cratis.io/...`, keep `description` apart
+  from the card `excerpt`.
+- **Landing page.** One primary term in the title, the `<h1>` or the first paragraph, and a
+  one-sentence definition above the fold. Brand lines stay; pair them with a category term in the
+  title and description. Respect the claim gate in `BRAND.md`, `MESSAGING.md` and `SITE.md`.
+- **README.** The H1 may be the product name ("Cratis <Product>"). The first sentence defines the product in 15-35 plain
+  nouns, with no logo-only or metaphor opener. Links are absolute; link the docs page.
+- **Package metadata.** One sentence naming what the package is and which Cratis product it belongs
+  to, identical to the README opener. `PackageProjectUrl` and `homepage` point at the docs page, not
+  only at GitHub. Read `references/package-metadata.md` for the field map.
+
+## Names
+
+Use the canonical names, one per concept, and the first-mention rule. Read
+`references/entities.md` when naming a product, writing a definition sentence or filling `sameAs`.
+Do not invent a name, URL, maturity word or claim that the references do not state.
+
+## Structured data
+
+Describe only what is visible on the page, one `@graph` per page, stable `@id`s. Add no `HowTo` and
+no new `FAQPage`. Read `references/structured-data.md` for the patterns and what each page type
+gets. Do not name people in structured data.
+
+## Checking a built site
+
+For a built static site (Astro `dist/` or a plain-HTML repository root), run with Node.js:
+`node <skill-directory>/scripts/verify-discoverability.mjs --root <dir> --site <https://host>`.
+It reports `<html lang>`, title, description, canonical host, `<h1>` count, JSON-LD parse errors,
+`robots.txt`, the sitemap and `llms.txt` structure. Errors exit 1; warnings do not. Pass
+`--warn-only` to downgrade errors and `--require-llms` where the site ships `llms.txt`.
+Read `scripts/verify-discoverability.mjs` only when changing the checker.
+
+## Pitfalls
+
+- Question headings everywhere: use them only where they read naturally (concept pages, FAQs,
+  comparisons, blog), never on reference pages or tutorial steps.
+- Padding to a word count: there is no minimum length; a complete page is done.
+- Apex `https://cratis.io/` links: the docs host is `https://www.cratis.io`.
+- A description that repeats the title or a sibling page's description.

package/package/corpus/skills/cratis-discoverability/references/entities.md

@@ -0,0 +1,68 @@
+# Entity names and definitions
+
+## Contents
+
+- Naming rules
+- Shared identifiers
+- Definition sentences
+- Disambiguation
+
+Only facts the Cratis repositories state are listed. If a product, URL or identifier is not here,
+find it in the product's own README or docs before writing it; do not guess.
+
+## Naming rules
+
+- First mention on a page: "Cratis Chronicle". Later mentions may be "Chronicle". In package
+  descriptions, README H1s and GitHub About text, always the prefixed form.
+- The product is Cratis Direct. "Direct" and "Stagehand" are internal or older names.
+- Cratis Build, Cratis Studio and Cratis Assurance are the three offers on cratis.no. In technical
+  copy and metadata, name the product (Chronicle, Arc), not the offer.
+- The product is not "Cratis.io". `cratis.io` is the docs host, canonical `https://www.cratis.io`.
+- "Cratis" alone is both the company and the platform. Say "the Cratis platform" where the company
+  could be meant.
+- Cratis Studio maturity: follow `BRAND.md` (Preview) until the owner decides otherwise.
+
+## Shared identifiers
+
+| Item | Value |
+| --- | --- |
+| Organization `@id` | `https://cratis.no/#organization` |
+| Company site | `https://cratis.no` |
+| Docs (canonical host) | `https://www.cratis.io` |
+| Blog | `https://blog.cratis.io` |
+| GitHub organization | `https://github.com/Cratis` |
+| NuGet profile | `https://www.nuget.org/profiles/Cratis` |
+| npm organization | `https://www.npmjs.com/org/cratis` |
+| YouTube | `https://www.youtube.com/@CratisStack` |
+
+Product docs follow `https://www.cratis.io/<product>/`.
+
+## Definition sentences
+
+Use these as the opening sentence of a definitional page, README or package description. Adjust only
+to fit the page; keep the facts.
+
+| Name | Sentence | Docs page (under `https://www.cratis.io`) |
+| --- | --- | --- |
+| Cratis (platform) | Cratis is an open-source (MIT) event sourcing and CQRS platform for .NET, built around the Chronicle event-sourcing database. | `https://www.cratis.io/` |
+| Cratis Chronicle | Cratis Chronicle is an open-source (MIT) event-sourcing database and runtime with a .NET kernel and clients for several languages. | `/chronicle/` |
+| Cratis Arc | Cratis Arc is an open-source (MIT) CQRS application framework for ASP.NET Core with generated TypeScript proxies. | `/arc/` |
+| Cratis Fundamentals | Cratis Fundamentals is the set of shared building blocks beneath the Cratis stack for .NET and TypeScript. | `/fundamentals/` |
+| Cratis Studio | Cratis Studio is a collaborative environment for designing, visualizing and editing Screenplay event models. | `/studio/` |
+| Cratis Direct | Cratis Direct is the managed control plane for the Cratis software factory: it turns GitHub signals into prioritized, governed AI work and reviewed pull requests. | none confirmed |
+| Cratis Cast | Cratis Cast is a profile-site engine and directory for the people who build with Cratis, with verified, event-sourced profile pages. | `https://cast.cratis.io` |
+| Cratis Screenplay | Cratis Screenplay is a business-oriented declarative language for specifying the desired functionality of an information system. | `/screenplay/` |
+| Cratis Stage | Cratis Stage compiles Screenplay source, verifies modeled specifications, and renders or partially performs Cratis applications. | none confirmed |
+| Cratis Prologue | Cratis Prologue captures selected signals from an existing system and interprets them into a provisional event model for review. | `/prologue/` |
+| Cratis CLI | The Cratis CLI is a terminal tool for inspecting and diagnosing Cratis Chronicle. | `/cli/` |
+| Chronicle Workbench | Chronicle Workbench is the web dashboard bundled with Cratis Chronicle for browsing events and operating a deployment. | `/chronicle/workbench/` |
+| Chronicle MCP | The Chronicle MCP server connects an AI agent to a running Cratis Chronicle database over the Model Context Protocol. | `/chronicle-mcp/` |
+
+Chronicle storage is pluggable (MongoDB by default, PostgreSQL, SQL Server, SQLite, in-memory).
+Arc works without event sourcing; the Chronicle integration is optional.
+
+## Disambiguation
+
+- `@cratis/arc` is the browser client of Arc .NET; `@cratis/arc.core` is the Node server package.
+- "Cast" alone is not the streaming protocol: write "Cratis Cast".
+- A docs slug not in the table is unconfirmed. Check the docs site before linking it.

package/package/corpus/skills/cratis-discoverability/references/package-metadata.md

@@ -0,0 +1,38 @@
+# Package metadata
+
+## Contents
+
+- Field map
+- Writing the description
+- Pitfalls
+
+## Field map
+
+| Field | NuGet (`.csproj`, `Directory.Build.props`) | npm (`package.json`) |
+| --- | --- | --- |
+| Description | `<Description>`, 80-250 characters; the first 100 are what shows | `description`, 80-160 characters |
+| Tags | `<PackageTags>`, 5-10, `cratis` plus category terms | `keywords`, the same list |
+| Project URL | `<PackageProjectUrl>` = `https://www.cratis.io/<product>/` | `homepage`, the same |
+| Repository | `RepositoryUrl` | `repository` |
+| Authors | `Cratis` | `author` `Cratis` |
+| License | `PackageLicenseExpression` `MIT` | `license` `MIT` |
+| Readme | A packed README with the same opener | `README.md` |
+
+Use a `https://www.cratis.io/<product>/` page that exists; check the docs site rather than guessing
+a slug. If none exists, leave the existing URL and report it.
+
+## Writing the description
+
+One sentence: what it is, for whom, and which Cratis product it belongs to - "<what it is> for
+<audience>, part of Cratis <Parent>". Name the parent so the package disambiguates ("the client for
+Cratis Chronicle, the open-source event-sourcing database"). The text equals the README opener and
+the GitHub About text. Tags are specific ("event-sourcing", "cqrs", "dotnet"); never "utilities".
+
+## Pitfalls
+
+- An empty `Description`.
+- Mixed `Authors` values across packages of one product.
+- `PackageProjectUrl` pointing only at GitHub.
+- Two packages with near-identical descriptions. Where `@cratis/arc` (the browser client of Arc
+  .NET) and `@cratis/arc.core` (the Node server package) could be confused, each description says
+  which one it is.

package/package/corpus/skills/cratis-discoverability/references/page-checklist.md

@@ -0,0 +1,88 @@
+# Page checklist
+
+## Contents
+
+- Field targets
+- Every page
+- Docs pages
+- Blog posts
+- Landing pages
+- READMEs
+- Before publishing a site change
+
+## Field targets
+
+Lengths are targets, counted in characters including any site suffix.
+
+| Field | Target |
+| --- | --- |
+| Title | Distinguishing term first. Blog and landing pages 50-60; docs and reference pages 20-60; a README H1 that is the product name is fine |
+| Description | One sentence, 60-160, never over 160; the point comes first |
+| Lead answer passage | 40-60 words, names its subject, one key property, one limit |
+| Heading | Under about 70 characters |
+| `og:image` | 1200x630, under 200 KB, with `og:image:alt` |
+
+## Every page
+
+- [ ] One reader job. For docs, one page type: tutorial, how-to, reference or explanation.
+- [ ] Title unique, distinguishing term near the front.
+- [ ] Description written by hand; not the title, not another page's description.
+- [ ] The `description` answers what the page is or achieves in one self-contained sentence; the first paragraph does too on landing, index, glossary and README pages.
+- [ ] Canonical names; first mention uses the full "Cratis X" form.
+- [ ] Facts, numbers and comparisons carry a source or a date; nothing beyond the claim gate.
+- [ ] Links have descriptive text. Root-relative inside the docs site, absolute
+      `https://www.cratis.io/...` elsewhere.
+- [ ] Images have alt text (empty only when decorative) and sensible size.
+- [ ] Linked from at least two other pages and from the right hub; no orphan.
+- [ ] Read aloud once: if it sounds written for a crawler, rewrite it.
+
+## Docs pages
+
+- Voice and structure follow `writing-cratis-docs`, which wins on any conflict: tutorials,
+  getting-started pages and explanations open with a concrete scenario (pain, then relief). Put the
+  answer-first definition in the frontmatter `description`; one definition sentence may follow the
+  scenario where it reads naturally.
+- Product index page: opens with the one-sentence definition, then the without-versus-with framing.
+- Concept page: scenario first; then why it exists, when to use it, when not to, how it works.
+  H2s such as "What is X" and "When to use X" only where they fit. No H1 in the body.
+- Tutorial: title names the outcome and starts with a verb; the scenario, then what the reader will
+  have running; prerequisites and versions up front; one visible result per step; "Last updated" and the
+  version it applies to.
+- How-to: the task as the title; goal, prerequisites, numbered steps, a done check, the two likely
+  failures; versions stated.
+- Reference: the title is the exact name with its product; first sentence says what it is for;
+  tables and signatures; stable anchors; no intro, no pitch. Merge or enrich near-empty stub pages.
+
+## Blog posts
+
+- [ ] Title states the topic; series name goes in a `series` field or at the end.
+- [ ] Two-sentence conclusion up front; "when this is the wrong fit" where it applies.
+- [ ] Named author where agreed (`cratis-team` only for company announcements), date, `lastUpdated`
+      only on real changes.
+- [ ] At least one internal link to the owning docs page; tags reused from the existing list, no
+      singleton tags; a cover image with alt text for posts likely to be shared.
+
+## Landing pages
+
+- [ ] One primary term in title, `<h1>` or first paragraph; one-sentence definition above the fold.
+- [ ] Description differs per page and is not a 300-character paragraph.
+- [ ] No testimonials, numbers, customers, prices or maturity claims the claim gate does not allow.
+- [ ] Norwegian pages are written natively, keep established English technical terms, link to the
+      English page with `hreflang`, and are not machine-translated and published unreviewed.
+
+## READMEs
+
+- [ ] H1 may be the product name ("Cratis <Product>"); first sentence is the definition (15-35 words, no metaphor).
+- [ ] Then install, a minimal working example, a link to `https://www.cratis.io/<product>/`,
+      license and how it relates to the rest of Cratis.
+- [ ] GitHub About text equals the README opener (80-160 characters); website is the docs page;
+      topics include `cratis` plus category terms.
+
+## Before publishing a site change
+
+- [ ] Title, description, canonical, Open Graph and JSON-LD present and unique on changed pages.
+- [ ] Sitemap lists new pages; `robots.txt` unchanged unless intended.
+- [ ] JSON-LD validates; no `HowTo`; no new `FAQPage`.
+- [ ] The content is in the raw HTML the server returns, not only rendered by JavaScript.
+- [ ] Internal links resolve; no apex `cratis.io` links.
+- [ ] A real HTTP 404 for unknown URLs; redirect stubs keep a canonical and stay out of the sitemap.

package/package/corpus/skills/cratis-discoverability/references/structured-data.md

@@ -0,0 +1,62 @@
+# Structured data patterns
+
+## Contents
+
+- Rules
+- Types per page type
+- Pattern
+
+## Rules
+
+- One `@graph` per page with stable `@id` values. The organization `@id` is
+  `https://cratis.no/#organization`.
+- Markup describes what is visible on the page, and every date is a real one.
+- Add no `HowTo`. Add no new `FAQPage`; keep the visible question and answer text. Use `QAPage` only
+  for real user questions and answers.
+- Do not name people (`Person`, `author` name) in structured data unless the owner has approved it.
+  Reference the organization by `@id`.
+- Do not add `offers`, an address or contact data without approval (see `SITE.md`).
+- Validate with the schema.org validator or Google's Rich Results Test. Invalid markup is worse than
+  none. Static sites hand-write `<script type="application/ld+json">`; Astro sites generate it in
+  the head component, so change it there rather than per page.
+
+## Types per page type
+
+| Page type | Types |
+| --- | --- |
+| Company home | `Organization` (name, url, logo, `sameAs`), `WebSite` |
+| Product marketing page | `SoftwareApplication` (name, applicationCategory, license, url, `sameAs`) |
+| Docs concept, tutorial, how-to, reference | `TechArticle` with `headline`, `dateModified`, plus `BreadcrumbList` |
+| Docs hub and landing page | `CollectionPage` or `WebPage`, not `TechArticle` |
+| Blog post | `BlogPosting` (`datePublished`, `dateModified`, `publisher`, `image`) |
+| Repository or sample code | `SoftwareSourceCode` |
+| Legal pages | `WebPage` |
+| 404 and app hosts | none |
+
+## Pattern
+
+```json
+{
+  "@context": "https://schema.org",
+  "@graph": [
+    {
+      "@type": "TechArticle",
+      "@id": "https://www.cratis.io/chronicle/projections/#article",
+      "headline": "Chronicle projections",
+      "description": "A projection declares how Chronicle builds a read model from events.",
+      "dateModified": "YYYY-MM-DD",
+      "publisher": { "@id": "https://cratis.no/#organization" },
+      "mainEntityOfPage": "https://www.cratis.io/chronicle/projections/"
+    },
+    {
+      "@type": "BreadcrumbList",
+      "itemListElement": [
+        { "@type": "ListItem", "position": 1, "name": "Chronicle", "item": "https://www.cratis.io/chronicle/" },
+        { "@type": "ListItem", "position": 2, "name": "Projections" }
+      ]
+    }
+  ]
+}
+```
+
+The values are illustrative: take the title, description and dates from the page itself.

package/package/corpus/skills/cratis-discoverability/scripts/verify-discoverability.mjs

@@ -0,0 +1,107 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+// Checks a built static site (Astro dist/ or a plain-HTML repo root) before it is published:
+// every indexable page has <html lang>, one <title>, a meta description, a canonical on the
+// expected host and parseable JSON-LD; the site has robots.txt, a sitemap and (optionally) a
+// well-formed llms.txt. Node standard library only.
+//
+// Usage: node verify-discoverability.mjs --root dist --site https://blog.cratis.io [--require-llms] [--warn-only]
+// Exit codes: 0 clean or warnings only, 1 errors, 2 could not run.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+const args = process.argv.slice(2);
+const option = (name, fallback) => { const i = args.indexOf(name); return i < 0 ? fallback : args[i + 1]; };
+const root = option('--root', 'dist');
+const site = option('--site');
+const requireLlms = args.includes('--require-llms');
+const warnOnly = args.includes('--warn-only');
+const ignore = (option('--ignore', 'node_modules,.git,.cratis,.github,404.html,_astro,storybook') ?? '').split(',');
+
+if (!site || !existsSync(root)) {
+    console.error(`could not run: need --site and an existing --root (got ${root})`);
+    process.exit(2);
+}
+const host = new URL(site).host;
+let errors = 0;
+let warnings = 0;
+const report = (level, file, message) => {
+    if (level === 'error' && !warnOnly) errors++; else warnings++;
+    console.log(`::${level === 'error' && !warnOnly ? 'error' : 'warning'} file=${file}::${message}`);
+};
+
+function* htmlFiles(dir) {
+    for (const name of readdirSync(dir)) {
+        if (ignore.includes(name)) continue;
+        const path = join(dir, name);
+        if (statSync(path).isDirectory()) yield* htmlFiles(path);
+        else if (name.endsWith('.html')) yield path;
+    }
+}
+
+const attr = (tag, name) => tag.match(new RegExp(`${name}\\s*=\\s*["']([^"']*)["']`, 'i'))?.[1];
+const tags = (html, pattern) => [...html.matchAll(pattern)].map(match => match[0]);
+const titles = new Map();
+
+for (const path of htmlFiles(root)) {
+    const file = relative(process.cwd(), path);
+    const html = readFileSync(path, 'utf8');
+    const metas = tags(html, /<meta\b[^>]*>/gi);
+    const robots = metas.find(tag => /name\s*=\s*["']robots["']/i.test(tag));
+    if (robots && /noindex/i.test(attr(robots, 'content') ?? '')) continue;      // deliberately not indexed
+    if (/http-equiv\s*=\s*["']refresh["']/i.test(html)) continue;                 // redirect stub
+
+    if (!/<html\b[^>]*\blang\s*=/i.test(html)) report('error', file, 'missing <html lang>');
+    const title = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.trim();
+    if (!title) report('error', file, 'missing or empty <title>');
+    else {
+        if (title.length > 65) report('warning', file, `title is ${title.length} characters; keep the distinguishing words in the first 60`);
+        titles.set(title, [...(titles.get(title) ?? []), file]);
+    }
+    const description = metas.find(tag => /name\s*=\s*["']description["']/i.test(tag));
+    const descriptionText = description ? attr(description, 'content') ?? '' : '';
+    if (!descriptionText) report('error', file, 'missing meta description');
+    else if (descriptionText.length < 60 || descriptionText.length > 160) report('warning', file, `meta description is ${descriptionText.length} characters (aim for 60-160)`);
+    const canonical = tags(html, /<link\b[^>]*>/gi).find(tag => /rel\s*=\s*["']canonical["']/i.test(tag));
+    const href = canonical ? attr(canonical, 'href') : undefined;
+    if (!href) report('error', file, 'missing <link rel="canonical">');
+    else {
+        try {
+            const url = new URL(href);
+            if (url.host !== host) report('error', file, `canonical points at ${url.host}, expected ${host}`);
+        } catch {
+            report('error', file, `canonical is not an absolute URL: ${href}`);
+        }
+    }
+    if ((html.match(/<h1\b/gi) ?? []).length !== 1) report('warning', file, 'expected exactly one <h1>');
+    for (const block of html.matchAll(/<script\b[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
+        try {
+            const data = JSON.parse(block[1]);
+            const nodes = Array.isArray(data) ? data : data['@graph'] ?? [data];
+            if (!Array.isArray(data) && !String(data['@context'] ?? '').includes('schema.org')) report('error', file, 'JSON-LD without a schema.org @context');
+            for (const node of nodes) if (!node['@type']) report('warning', file, 'JSON-LD node without @type');
+        } catch (error) {
+            report('error', file, `JSON-LD does not parse: ${error.message}`);
+        }
+    }
+}
+
+for (const [title, files] of titles) if (files.length > 1) report('warning', files[0], `title "${title}" is shared by ${files.length} pages`);
+
+const robotsPath = join(root, 'robots.txt');
+if (!existsSync(robotsPath)) report('error', root, 'no robots.txt');
+else if (!/^\s*sitemap\s*:/im.test(readFileSync(robotsPath, 'utf8'))) report('warning', robotsPath, 'robots.txt does not declare a Sitemap');
+if (!readdirSync(root).some(name => /^sitemap.*\.xml$/.test(name))) report('error', root, 'no sitemap*.xml at the site root');
+
+const llmsPath = join(root, 'llms.txt');
+if (existsSync(llmsPath)) {
+    // Same structure rules as vendor/claude-seo/scripts/agentic_check.py evaluate_llms_txt (Lighthouse llms-txt audit).
+    const llms = readFileSync(llmsPath, 'utf8').replace(/^\uFEFF/, '');
+    if (!/^\s*#\s+.+/m.test(llms)) report('error', llmsPath, 'llms.txt has no H1');
+    if (!/\[.+\]\(.+\)/.test(llms)) report('error', llmsPath, 'llms.txt has no Markdown links');
+    if (!/^\s*>\s+\S/m.test(llms)) report('warning', llmsPath, "llms.txt has no '>' summary");
+} else if (requireLlms) report('error', root, 'no llms.txt');
+
+console.log(`verify-discoverability: ${errors} error(s), ${warnings} warning(s)`);
+process.exit(errors ? 1 : 0);

package/package/corpus/skills/cratis-discoverability/verification.json

@@ -0,0 +1,13 @@
+{
+  "skill": "cratis-discoverability",
+  "input": "Run the pre-publish discoverability check on a new blog post, a package README and the package metadata for a Cratis library.",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "If a fix makes the page worse to read," },
+    { "kind": "skill-contains", "value": "Add no `HowTo` and" },
+    { "kind": "skill-contains", "value": "Do not name people in structured data." },
+    { "kind": "skill-contains", "value": "Apex `https://cratis.io/` links: the docs host is `https://www.cratis.io`." },
+    { "kind": "skill-contains", "value": "no logo-only or metaphor opener" },
+    { "kind": "skill-contains", "value": "Padding to a word count: there is no minimum length" }
+  ]
+}

package/package/corpus/skills/cratis-screenplay-command-surface/references/text-and-match-rules.md

@@ -63,6 +63,23 @@ settings. Syntax remains `matches "^INV-[0-9]{6}$"` or `matches email`.
 
 `\s` includes U+00A0, U+FEFF and Unicode line/paragraph separators; it excludes
 U+0085. Dot excludes LF, CR, U+2028 and U+2029. `\w` excludes U+0130.
+### Write unambiguous patterns (PLAY0803)
+
+Requires Screenplay 4.218.2 or later (`screenplay --version`); older compilers do not warn.
+
+Generated clients run the pattern in a browser's backtracking engine, so an exponentially
+ambiguous pattern can hang a tab on a crafted value even though Screenplay's own automaton
+stays linear. The warning `PLAY0803` (`AmbiguousMatchPattern`) names the ambiguous
+subexpression and a simpler rewrite where one exists; C#, TypeScript, Monaco and VS Code
+report it identically. Very large patterns are not analyzed, so keep them small anyway.
+
+| Ambiguous | Write instead |
+| --- | --- |
+| `(a+)+$`, `(a*)*` | `a+`, `a*` (never quantify a group whose body already repeats) |
+| `(a\|a)*` | `a*` (alternatives must not match the same text) |
+
+Prefer a character class such as `[ab]*` over alternatives that overlap. Fix the pattern rather than suppressing the warning; validate with `--warnings-as-errors`.
+
 `matches email` is conservative, not RFC 5322: one `@`, nonempty local part without
 whitespace/`@`, and at least two nonempty domain parts without whitespace/`@`.
 A no-break space therefore fails email validation. Other bare names report PLAY0366.

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

@@ -278,7 +278,7 @@ See read-surface `references/named-keys.md` for the collection-key exclusion alg
 | Protected command reads (ESM v25) | Root `command reads protected`; eligible read paths in requirements and production mappings, absence Validation, concurrent matching facts Conflict; Stage admits v25 and, in a new enough bundle, renders protected reads as Arc read protection, refusing unpreservable shapes and every older bundle with STAGE-ESM-044; semantic Host/executor execute admitted reads with non-Error protected requirements refused STAGE-ESM-045 |
 | Chronological command dates (ESM v26) | Same-primitive Date/DateTime `==`, `!=`, `>`, `>=`, `<`, `<=` in require/produces-when (property or literal RHS) and command/property rules (literal RHS only). DateTime uses UTC ticks, participating offset-less inputs reject Validation before rules; then matching stays ordinal. Requires Screenplay 4.199.0 (`screenplay --version`); older binders refuse PLAY0268. The Stage Host and executor run v26 (older Stage refuses STAGE-ESM-016); the renderer and legacy engines refuse STAGE-ESM-046 (toolchain `language-admission.md`). Read command-surface `references/date-comparisons.md`. |
 | Current routing and actor admission | Sources/streams and command/specification routes bind and reference-execute as v8; reaction `runs as system role` supplies the invocation actor as v10. Whole-workspace binding determines executable availability; CLI/Stage realization remains separate |
-| Blocks binding (`PLAY0268`) | enum/identity compliance and events combining personal or explicitly subject-scoped secret values with explicit subject marks; a compiler that stops before v13 refuses all `pii`/`secret` concepts ("compliance attributes require portable data-subject semantics"), while v13 binds them and Stage renders protection; bare `rule <Name>`, read paths without protected opt-in or in unsupported positions such as `produces when`, date comparisons with mixed primitives, optional condition operands, `$context`, protected read paths or `today`, date rules on concepts or reaction `where`, `$context.tenant`/claims/roles/causation in `produces`, `$env` conditions, `file` constraints, unquoted `import` of an external contract, a read model with neither explicit `key` nor unambiguous query-based identity as described above (several key marks bind as v27; older binders refuse PLAY0268; toolchain `language-admission.md`), queries with context `from` sources (typed query context is unadmitted), single-result filters (collections only), `scoped to` (opaque scope), `performer` (opaque implementation) or a `by` block on a list query or non-optional single result; optional keyed and collection queries, including caller-supplied equality filters and observable delivery, bind, `$causedBy` and templates in projections |
+| Blocks binding (`PLAY0268`) | enum/identity compliance and events combining personal or explicitly subject-scoped secret values with explicit subject marks; a compiler that stops before v13 refuses all `pii`/`secret` concepts ("compliance attributes require portable data-subject semantics"), while v13 binds them and Stage renders protection; bare `rule <Name>`, read paths without protected opt-in or in unsupported positions such as `produces when`, date comparisons with mixed primitives, optional condition operands, `$context`, protected read paths or `today`, date rules on concepts or reaction `where`, `$context.tenant`/claims/roles/causation in `produces`, `$env` conditions, `file` constraints, unquoted `import` of an external contract, a read model with neither explicit `key` nor unambiguous query-based identity as described above (several key marks bind as v27; older binders refuse PLAY0268; toolchain `language-admission.md`), queries with context `from` sources (typed query context is unadmitted), single-result filters (collections only), `scoped to` (opaque scope) or a `by` block on a list query or non-optional single result (a `performer` query is not refused: it is an opaque read, PLAY0270, left out of the executable model; [version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)); optional keyed and collection queries, including caller-supplied equality filters and observable delivery, bind, `$causedBy` and templates in projections |
 | Blocks binding (`PLAY0800`, permanent attachment requirement) | Attached file/inline command `handler`: gap-fill the slice with a constrained implementation attachment, not by waiting for ESM admission. PLAY0035 beside productions; pending described intent instead binds v23. Read required typed `arguments.subject` for the command, never parse the message. Compiler prerequisite and older PLAY0268 attribution: [diagnostic arguments](../../cratis-screenplay-toolchain/references/diagnostic-arguments.md) |
 | Blocks binding (`PLAY0271`, legacy meaning) | Command reads without protected opt-in and `concurrency`; combined protected reads/concurrency is PLAY0783 |
 | Deferred (`PLAY0269`, information) | Screens, layouts, templates, forms, contributions, UI profiles, themes, behaviors and `on`/`uses` |

package/package/corpus/skills/cratis-screenplay-model-authoring/references/mcp-tools.md

@@ -451,7 +451,14 @@ correctness repair; PLAY0667–0670 require an author decision, with no automati
 
 Sources/streams and command/specification routes bind as ESM v8 and have
 catalog identities; `executionAvailable` still requires whole-workspace binding.
-Source/stream `propose-rename` repairs bound route references. Operations and
+Source/stream `propose-rename` repairs bound route references. `propose-rename` also
+renames a composite stream-id part: it rewrites the part declaration and every
+`part = ...` mapping in command routes, specification routes, examples and redelivery
+locators, keeps part order and stored stream ids, and is refused
+when the new name collides with another part of the same stream. Use it instead of a
+hand-written `propose-ast` batch.
+Requires Screenplay 4.220.0 (`screenplay --version`) for part renames; older servers
+cannot rename a part through `propose-rename`. Operations and
 exact numeric mode remain unadmitted. Check installed schemas, especially when
 the CLI bundle predates the standalone tool.
 
@@ -626,7 +633,12 @@ Upgrade before treating those rows as a coverage gate.
 `find-modeling-smells` asks information-level questions, never changes compilation
 or `--warnaserror`: SMELL001 generic event endings, SMELL002 generic command verbs,
 SMELL003 duplicate nonempty event shapes from different commands, SMELL004 event
-fan-out, SMELL005 read-model property fan-in. Optional scope/document and
+fan-out, SMELL005 read-model property fan-in (counts only the events that actually
+feed the property, not every known event through a projection `all` block), SMELL006
+an event property that no mapping, AutoMap, reaction, condition or specification
+reads (worded as a question: dead data or a missing reader?).
+Requires Screenplay 4.221.0 (`screenplay --version`) for SMELL006 and the corrected
+SMELL005 count; older servers over-report SMELL005 and never report SMELL006. Optional scope/document and
 `eventFanOutThreshold`/`propertyFanInThreshold` (default 5, integers 1–200) bound
 selection; equal to threshold is not flagged. Similar shape does not establish
 similar meaning: report a defect only with a domain consequence. No per-declaration

package/package/corpus/skills/cratis-screenplay-model-review/SKILL.md

@@ -53,8 +53,8 @@ model's behalf.
 
 3. **Element sweep** (phase 1, mechanical, before any judgement). One line per gated element, event,
    name, command, event property and slice; `references/checklist.md` S1-S7 gives each line's
-   format. Scoped `find-modeling-smells` supplies advisory generic-name, duplicate-shape
-   and wide-flow questions, never compiler defects or a substitute for the sweep. Each `NONE` and each form name is its own finding naming that element. A repeated
+   format. Scoped `find-modeling-smells` supplies advisory generic-name, duplicate-shape,
+   wide-flow and unread-event-property questions, never compiler defects or a substitute for the sweep. Each `NONE` and each form name is its own finding naming that element. A repeated
    payload or generic verb is a signal to investigate: report it only when the name or payload
    hides the business reason or a consequence is shown (distinct facts that share a shape and
    earlier generations are not findings). A description, comment or spec name never excuses a flagged line.

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

@@ -52,8 +52,8 @@ not why: a signal, so confirm the hidden reason before reporting. The fix names
 change (`BerthReassigned`, `BerthLengthLimitRaised`), one event per reason, each with its own
 rules and consumers. A shared payload shape alone is not a defect: full generations repeat the
 prior shape on purpose and different facts may look alike. Screenplay 4.127.0 MCP
-`find-modeling-smells` reports advisory questions (SMELL001–SMELL005) for generic
-names, duplicate shapes and wide flows. It supplements the sweep, never changes
+`find-modeling-smells` reports advisory questions (SMELL001–SMELL005; SMELL006 needs a newer server, see [MCP tools](../../cratis-screenplay-model-authoring/references/mcp-tools.md)) for generic
+names, duplicate shapes, wide flows and event properties nothing reads. It supplements the sweep, never changes
 a compiler verdict or proves a domain defect.
 
 ## Phase 2. Entity walk (5 checks, T1-T5; feeds F1-F3 and scenario coverage)
@@ -180,7 +180,7 @@ Nebulit (`provenance.md`).
 | Id | Check | Evidence | Tier |
 |---|---|---|---|
 | H1 | Query shape follows the business view (list where people scan; lookup where they open one) | queries, screens | D |
-| H2 | Executable scope: a keyed `=> RM optional` query with `by` named like a read-model property, or a collection (`=> RM[]`, observable too) with caller-supplied `by` and/or equality filters. `from`, single-result filters, opaque `scoped to`/`performer` and a list-query `by` block remain PLAY0268. A read model with several key parts binds as v27 (Requires Screenplay 4.204.0). The projection routes by the same identity (a `from` key or an event property, or `$eventSourceId`; `$eventSourceId` is not mandated). Filtered models: supported v14 equality filters render within the CLI bundle's ESM ceiling. Renderable scope only: Stage-specific identity/filter limits; keyed optional snapshot lookups and snapshot/observable collections render (Requires Stage 4.90.0 for snapshot lists; older renderers report `STAGE-ESM-010`). Check query concept-validation parity separately; primitive-argument targets answer absence instead of Validation | queries, projections | C (executable); C (render admission, renderable only) |
+| H2 | Executable scope: a keyed `=> RM optional` query with `by` named like a read-model property, or a collection (`=> RM[]`, observable too) with caller-supplied `by` and/or equality filters. `from`, single-result filters, opaque `scoped to` and a list-query `by` block remain PLAY0268; a `performer` query is an opaque read (PLAY0270) left out of the executable model ([version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)). A read model with several key parts binds as v27 (Requires Screenplay 4.204.0). The projection routes by the same identity (a `from` key or an event property, or `$eventSourceId`; `$eventSourceId` is not mandated). Filtered models: supported v14 equality filters render within the CLI bundle's ESM ceiling. Renderable scope only: Stage-specific identity/filter limits; keyed optional snapshot lookups and snapshot/observable collections render (Requires Stage 4.90.0 for snapshot lists; older renderers report `STAGE-ESM-010`). Check query concept-validation parity separately; primitive-argument targets answer absence instead of Validation | queries, projections | C (executable); C (render admission, renderable only) |
 | H3 | One builder per read model; projection `key` only on `from` | projections | C |
 | H4 | Screens show one actor's point of view; a form submits one command | screens, forms | D |
 

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

@@ -32,7 +32,8 @@ the Screenplay MCP views.
    for obligations with no matching specification. These read authored examples, not executed
    coverage (`../../cratis-screenplay-model-authoring/references/mcp-tools.md`).
 5. Gaps and orphans: `find-references` and `dependencies` for declarations referenced by nothing;
-   `find-modeling-smells` for the candidate shapes.
+   `find-modeling-smells` for the candidate shapes; SMELL006 names event properties no
+   mapping, reaction, condition or specification reads, a question to answer, not a defect.
 
 ## Report
 Asked conversationally, give the summary and the most important gap and offer the full lists on request.

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

@@ -9,7 +9,7 @@ reference execution.
 |---|---|
 | The MCP tool catalog (`describe-application`, `search-declarations`, `dependency-graph`, `find-assertion-gaps`, `read-workspace`, `declaration-details`) | `Screenplay`: `Source/DotNET/Screenplay.Mcp/McpToolCatalog.cs`, `Documentation/screenplay/mcp/reference.md` |
 | Diagnostics PLAY0029, PLAY0191, PLAY0268, PLAY0271, PLAY0350, PLAY0381, PLAY0469; one data subject per event | `Screenplay`: `Source/DotNET/Screenplay/Diagnostics/DiagnosticCodes.cs`, the decision record on data subjects |
-| `find-specification-obligations` (SPEC001 to SPEC008, authored presence) and `find-modeling-smells` (SMELL001 to SMELL005, advisory questions); neither proves executed behavior or complete lineage | `Screenplay`: `Documentation/screenplay/mcp/reference.md` |
+| `find-specification-obligations` (SPEC001 to SPEC008, authored presence) and `find-modeling-smells` (SMELL001 to SMELL006, advisory questions); neither proves executed behavior or complete lineage | `Screenplay`: `Documentation/screenplay/mcp/reference.md` |
 | `semantic-diff` source objects and revision-pinned pages | `Screenplay`: `Source/DotNET/Screenplay.Mcp/` (`McpRevisionDiff`, `McpWorkspaces.Comparison`), `Documentation/screenplay/mcp/reference.md` |
 | Model notes: anchors, kinds, the committed sidecar, the open-question gate | `Screenplay`: `Documentation/screenplay/model-notes.md`; notes tools in model-authoring `references/model-notes.md` |
 | Property links and their roles for lineage and journey tracing | `Screenplay`: `Documentation/screenplay/mcp/reference.md`; model-authoring `references/property-links.md` |

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

@@ -85,7 +85,7 @@ is not the same thing. Rules and diagnostics:
 **Name the compiler and renderer.** Optional keyed queries and collection queries
 bind, including `observable`. Caller-supplied equality
 filters on collections bind as ESM v14; `from`, single-result filters, `scoped to`,
-`performer` and a `by` block on a list query (or on a non-optional single result) remain PLAY0268, each with its reason. Read
+and a `by` block on a list query (or on a non-optional single result) remain PLAY0268, each with its reason. A `performer` query is not refused: it is an opaque read (PLAY0270 information) left out of the executable model ([version gate](../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)). Read
 [equality filters](references/equality-filters.md) for the admitted shape, a complete
 compiled specification model and the Stage/CLI ceilings. Keep a list the domain needs.
 
@@ -166,7 +166,7 @@ precondition. It takes a `file` reference or an inline block in a tagged fence
 (` ```csharp `, ` ```sql `), and is the query's counterpart to a command's
 `handler`. The parser accepts any registered inline language and does not reject
 a nonsensical one, so the choice is yours to get right. Performer code is opaque:
-Screenplay never runs it.
+Screenplay never runs it. It is reported as information `PLAY0270` and left out of the executable model; a specification that reads it is left out while every other specification still runs. Older compilers refuse it with PLAY0268: see the [version gate](../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does).
 
 A read model a performer composes needs no projection, and no event builds it.
 Specify it from state with `given readmodel`, then `when query <Query>` with the
@@ -183,7 +183,7 @@ Caller-supplied equality filters on collections select ESM v14 (Requires Screenp
 primitive/concept/enum properties, same nominal type ignoring optionality, no
 `from`, distinct names not repeating `by`. `by` and supplied filters AND together;
 optional filters may be omitted, but supplied null is refused. PLAY0268 still
-rejects context sources, single-result filters, opaque scope/performer and
+rejects context sources, single-result filters, opaque scope and
 a `by` block on a list query (or on a non-optional single result).
 Authorization runs before lookup, ANDed with module/feature gates; policies see
 only `by`, never filters. Pin denial with `given caller` and `then denied`.

package/package/corpus/skills/cratis-screenplay-read-surface/references/equality-filters.md

@@ -39,7 +39,7 @@ Each binding refusal reports PLAY0268 with its query/filter and reason:
 | `filter ... from ...` or context-derived `by` | Typed query context sources are not admitted; a caller argument must not stand in for trusted context |
 | Filter on a single-result query | Equality filters are admitted only for collections |
 | `scoped to` | The named scope has no portable executable scope contract |
-| `performer` | Query implementation code is opaque, not a portable declarative lookup |
+| `performer` | Query implementation code is opaque. Requires Screenplay 4.220.1 (`screenplay --version`) for it to be an opaque read (PLAY0270 information) left out of the executable model; older compilers refuse it with PLAY0268 and leave the model unbound |
 | `by` block on a collection query | A composite lookup is admitted only for an optional single-instance query; narrow a list by composite-keyed read-model parts with equality filters instead |
 | Filter on a collection/composite property, missing property or mismatched nominal type | The v14 filter contract requires a same-named scalar primitive, concept or enum property with the same type |
 

package/package/corpus/skills/cratis-screenplay-read-surface/references/named-keys.md

@@ -25,7 +25,7 @@ selection is:
    (case-sensitive). It first excludes collection-query `by` properties: if exactly
    one candidate remains, that is the identifier; otherwise it uses all `*Id`
    candidates and requires exactly one. An admitted list query here is a collection
-   query without context-derived `by`, filters, scope or performer.
+   query without context-derived `by`, filters or scope.
 
 A projection-only/queryless read model needs an explicit `key`: a lone `*Id`
 property alone does not infer identity. Never use the command's `identifier`

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

@@ -35,7 +35,7 @@ ESM). Only the probe answers renderability. `PLAY0270` entries are information,
 | Class | Meaning | Typical examples (each verified in `admission.md`) | Action |
 | --- | --- | --- | --- |
 | **Model fix (in mode)** | the model is in, or the user chose, renderable mode and breaks its own subset in a way that has a renderable equivalent with the same meaning | a `produces` whose `for` is not the command identifier; two projections for one read model (`-007`); a policy Stage cannot express portably (`-015`; role-only and opaque pure policies render) | edit request to the modeler session with address, change and rationale |
-| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to`/`performer` and a list-query `by` block remain PLAY0268; a read model with several key parts or a projection keyed by parts (v27) refuses `STAGE-ESM-048` and a single-instance query by parts `STAGE-ESM-047` (Chronicle#4265); Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected reads the renderer cannot preserve, or any protected read in an older CLI bundle (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-043; v22 admission Requires Stage 4.139.0, older Stage reports -016) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
+| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to` and a list-query `by` block remain PLAY0268; a query `performer` (opaque read, PLAY0270) is left out of the model so render emits nothing for it: write the code the model needs by hand as a gap-fill item; a read model with several key parts or a projection keyed by parts (v27) refuses `STAGE-ESM-048` and a single-instance query by parts `STAGE-ESM-047` (Chronicle#4265); Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected reads the renderer cannot preserve, or any protected read in an older CLI bundle (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-043; v22 admission Requires Stage 4.139.0, older Stage reports -016) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
 | **Implementation attachment** | a permanent limitation, not future ESM admission | file/inline command handlers (PLAY0800; typed `subject` names the command) | keep the model contract and gap-fill the slice in code with a constrained implementation attachment; do not wait for a new ESM version |
 | **Tool skew** | the bundled compiler disagrees with documented semantics | the false `PLAY0285` on reaction cascades from an older bundle; codes the standalone compiler does not raise | record in the session state and the fallback record; never "fix" a correct model |
 | **Environment** | not the model | restore failures, missing SDK, a destination that is not writable | fix the environment or report blocked |

package/package/corpus/skills/cratis-screenplay-scenario-coverage/SKILL.md

@@ -131,7 +131,11 @@ proved and keep other guarantees as target requirements; recovery cases are in
 - One behaviour per spec; names read as sentences: `Reserving...`, `Rejecting...`, `Refusing...`
   (denial), `<View>LifecycleN<State>` for families.
 - `for` on every given, appended and expected event (plain `produces <Name>` too; inline `produces event` omits it), and on the `when` command where the
-  destination matters. A competing-claim given needs a *different* `for`.
+  destination matters. A competing-claim given needs a *different* `for`. A given without `for`
+  belongs to the event source the specification acts on; state `for` when the command appends to
+  several event sources or an assertion depends on the given's source, and never assert
+  `$eventSourceId` of a sourceless given. Read
+  [examples and routes](../cratis-screenplay-specifications/references/examples-and-routes.md#givens-without-an-event-source).
   Foreign event fixtures feeding a capture may omit `for`; supplied `for` is
   opaque source text, not the capture's content key.
 - Format rules belong on a `concept`: give each concept rule representative acceptance,
@@ -147,7 +151,9 @@ proved and keep other guarantees as target requirements; recovery cases are in
 - Descriptions are not rendered: a rule only in prose is unenforced; make it a rule layer, a
   spec or a recorded target requirement.
 - Prove projections with events (`given`/`when append`), not `given readmodel`; seed read models
-  only for performer-backed views or commands that decide on view state.
+  only for performer-backed views or commands that decide on view state. A query `performer` is an opaque read
+  (information `PLAY0270`, not `PLAY0268`): it is left out of the executable model, a spec that reads it is
+  left out too and the other specs still run, so mark it `gap` for the executable modes ([version gate](../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)).
 - No contradiction between a family and single-transition specs of the same view.
 
 ### Quality checklist (adapted from the TrogonStack scenario checklist; `references/provenance.md`)

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

@@ -219,6 +219,6 @@ empty-list intent is a separate claim from a keyed row being absent (`view-and-s
 queries are executable too (`ListOpenInvoices` in the backing example); caller-supplied equality filters on collections bind as ESM v14.
 Pass `by` and filters in query arguments; PLAY0468 reports unknown, repeated or
 missing required arguments. Optional filters may be omitted, supplied null is refused.
-Context-sourced/single-result filters, opaque `scoped to`/`performer`, and a list-query
-`by` block remain PLAY0268. Compiled coverage and renderer ceilings:
+Context-sourced/single-result filters, opaque `scoped to`, and a list-query
+`by` block remain PLAY0268; a `performer` query is an opaque read left out of the model (PLAY0270; [version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)). Compiled coverage and renderer ceilings:
 read-surface [equality filters](../../cratis-screenplay-read-surface/references/equality-filters.md).

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

@@ -24,7 +24,7 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | `then readmodel` / `then query` (keyed `ById`, `arguments`, `result`) | yes | yes | yes |
 | `then query` on an unfiltered list or a list narrowed by one `by` key (observable too) | yes | yes: no `arguments` for an unkeyed list, one `result` per row stating the read-model identifier, no `result` = empty list | snapshot and observable lists render |
 | Collection query with caller-supplied equality `filter`, including observable | yes | yes, ESM v14: same-named scalar property/type, AND with `by`; optional omission allowed, supplied null refused; PLAY0468 checks arguments; row order does not matter | yes on supported snapshot/observable collections; DateTime/filter parameter order refuse -010; independent Stage executor still refuses filtered assertions (-010) |
-| Context `from`, single-result filters, `scoped to`, `performer` or a list-query `by` block | yes | PLAY0268: query context, collection-only filtering, opaque scope/implementation or a multipart list lookup are unadmitted | no |
+| Context `from`, single-result filters, `scoped to` or a list-query `by` block | yes | PLAY0268: query context, collection-only filtering, opaque scope or a multipart list lookup are unadmitted | no |
 | `then no readmodel <RM> for "<key>"` | yes | yes | no |
 | `when query` -> `then result` / `then no result` | yes | yes | same as `then query`: only the query-only cases below |
 | `given clock` / `when clock`, `when trigger`, record-source `given`/`when capture` | yes | yes (standalone and any cratis whose compiler admits v6; an older bundle does not, see toolchain `references/executable-subset.md`) | no |
@@ -45,7 +45,8 @@ Typed example/override forms: `cratis-screenplay-specifications`
 | Bodied rules, code policies | spec them | spec reported **unsupported**, never passed | no |
 | Pending described command handlers (v23) | specify intent | binds; denial/validation execute, body-reaching specs Unsupported ImplementationBody; all-Unsupported is not green | STAGE-IMPL-002 even Stub mode |
 | Attached command handlers | spec them in design | blocked: PLAY0800, no spec runs (V3 blocked); permanent constrained-attachment requirement, gap-fill in code | no |
-| `file` constraints, query `performer`s | spec them in design | blocked: PLAY0268 at binding, no spec runs (V3 blocked) | no |
+| `file` constraints | spec them in design | blocked: PLAY0268 at binding, no spec runs (V3 blocked) | no |
+| Query `performer`s | spec them in design | opaque read: PLAY0270 information, left out of the executable model; a spec that reads it is left out, every other spec still runs ([version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does); older compilers report PLAY0268) | no |
 | Atomic reaction mode (v22) | declare for new models | failed batch adds no facts or view changes; earlier batches/commands remain; `then error` alone is insufficient | v22 STAGE-ESM-016; mode in admitted v23–v27 STAGE-ESM-043 |
 | Protected command reads (v25) | declare opt-in for eligible reads | absence Validation; matching intervening facts Conflict; race vectors are not a new spec construct | Cratis C# rendering in a new enough bundle (STAGE-ESM-044 before, or for unpreservable shapes); semantic Host/executor execute admitted reads, non-Error protected requirements STAGE-ESM-045; v25 pair admitted |
 
@@ -58,7 +59,7 @@ Requires Stage 4.90.0 for snapshot/live lists, 4.101.0 for no-event specificatio
 
 ## Design mode
 Write the full intended behaviour, including scenarios the executable subset cannot run
-(filtered, scoped and performer-backed views; clock, trigger and capture scenarios when only a
+(filtered, scoped and performer-backed views, the last left out of the executable model rather than refused; clock, trigger and capture scenarios when only a
 older cratis bundle is available). Mark each such spec in the coverage matrix as
 `gap: <reason>` for the narrower modes so the verification and render phases know what will not execute.
 

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/view-and-story-specs.md

@@ -61,7 +61,7 @@ own full givens. The excerpt is copied from `invoicing-dues-example.md`; the las
 both that the stored row is gone and that the keyed query returns nothing. The whole-list query
 (no key) is executable too (Requires Screenplay 4.105.0 or later): `invoicing-dues-example.md` adds
 `ListOpenInvoices => OpenInvoice[]` with one spec that expects one `result` row and one that
-expects the empty list after `PaymentReceived`. Only `filter`, `scoped to` and `performer` queries stay design-mode.
+expects the empty list after `PaymentReceived`. Only `filter`, `scoped to` and `performer` queries stay design-mode (a performer query is left out of the executable model, not refused).
 The source document also asserts the other terminal outcomes (`InvoiceVoided`, `InvoiceSettled`) the same way; they are not copied here.
 ```screenplay excerpt parent=references/invoicing-dues-example.md#1
 specification OpenInvoicesLifecycle1Empty

package/package/corpus/skills/cratis-screenplay-slice-design/SKILL.md

@@ -120,7 +120,7 @@ Ask the batch below only for what the request leaves open: (1) origin of each ac
 
 - At most one `identifier` per command; never on an event property or read-model property (use `key`). At most one builder per read model (`PLAY0191`). Read `references/read-model-design.md` ("Identifier and key contract") for the exact rules.
 
-- A query's `by` goes on its own body line; `from`, single-result filters, scope, performer and a list-query `by` block remain `PLAY0268`; equality filters on collections bind as ESM v14. Read `references/read-model-design.md` ("Query binding") for the binding rules.
+- A query's `by` goes on its own body line; `from`, single-result filters, scope and a list-query `by` block remain `PLAY0268` (a `performer` query is an opaque read left out of the executable model, [version gate](../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)); equality filters on collections bind as ESM v14. Read `references/read-model-design.md` ("Query binding") for the binding rules.
 
 - A `unique` constraint names a property the event declares directly; the constraint name is
   its identity (renaming starts an empty index).

package/package/corpus/skills/cratis-screenplay-slice-design/references/read-model-design.md

@@ -330,8 +330,9 @@ module Berths
 - A query's `by` goes on its own body line. Optional keyed and collection queries
   bind, including observable delivery. Caller-supplied equality filters on collections
   bind as ESM v14; `by` ANDs with supplied filters. `from`, single-result
-  filters, scope, performer and a `by` block on a list query remain PLAY0268 for their
-  respective context/cardinality/opaque/multipart gaps. A composite-keyed optional
+  filters, scope and a `by` block on a list query remain PLAY0268 for their
+  respective context/cardinality/opaque/multipart gaps. A `performer` query is an opaque read left
+  out of the executable model, not PLAY0268 ([version gate](../../cratis-screenplay-toolchain/references/executable-subset.md#code-attachments-what-binds-what-never-does)). A composite-keyed optional
   single-instance query takes a `by` block naming every part (ESM v27). Read read-surface
   [equality filters](../../cratis-screenplay-read-surface/references/equality-filters.md).
 

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

@@ -238,7 +238,10 @@ For command specifications:
 - [ ] `given caller` is present whenever the command is authorized, with a
       `then denied` case for a caller who must be refused.
 - [ ] `then` contains **either** events **or** an error, never both.
-- [ ] A collision between two event sources uses `for` on the `given` event.
+- [ ] A collision between two event sources uses `for` on the `given` event. A `given` without
+      `for` belongs to the event source the specification acts on; state `for` when the command
+      appends to several event sources or an assertion depends on it (see
+      [examples and routes](references/examples-and-routes.md#givens-without-an-event-source)).
 - [ ] Error cases test business rules; each concept rule has one rejection
       specification through one command, not one per use.
 - [ ] A localized rejection is pinned by its quoted `$strings` key.
@@ -248,7 +251,8 @@ For command specifications:
 For view specifications:
 
 - [ ] A view a `performer` composes is specified with `given readmodel`,
-      `when query` and `then result` or `then no result`.
+      `when query` and `then result` or `then no result`; the reference runner leaves such a
+      spec out (`PLAY0270` information), so it is design intent, not executed proof.
 - [ ] `given readmodel` is a complete instance with its identifier.
 - [ ] `then readmodel` states the identifier and the properties that matter; add
       `exactly` only when extra properties must fail the assertion.

package/package/corpus/skills/cratis-screenplay-specifications/references/examples-and-routes.md

@@ -11,6 +11,7 @@
 - Event routes
 - Redelivery locators
 - Operation and recovery intent
+- Givens without an event source
 
 ## Typed examples
 
@@ -223,3 +224,21 @@ future external-work behavior. Use `then no events` to assert explicitly that th
 action and cascade produced no new facts; after append it excludes the input fact.
 It may accompany view/query/response assertions, not events, event-order assertions,
 errors or denial (PLAY0545). An omitted event list is not this explicit assertion.
+
+## Givens without an event source
+
+A `given` event with no `for` belongs to the event source the specification acts on: the
+event source each fact the command appends goes to, or the `for` of `when append`.
+
+- A unique-event constraint counts a sourceless given as already on that event source. A
+  unique-value constraint treats its value as the action's own claim.
+- When a projection needs the given's event-source identity, the reference evaluator reports
+  `Unsupported` (Projection) and does not invent one. This holds whatever the action,
+  because givens are projected before it runs.
+- Runners that append to real event streams, such as Stage, append sourceless givens to the
+  action's event source.
+- State `for` when the command appends to more than one event source, or when an assertion
+  depends on the given's event source. Never assert `$eventSourceId` of a sourceless given.
+
+Requires Screenplay 4.229.0 (`screenplay --version`) for the documented, vector-pinned
+placement; older versions leave a sourceless given's placement unspecified.

package/package/corpus/skills/cratis-screenplay-streams-and-consistency/references/stream-id-rules.md

@@ -13,4 +13,8 @@ Rules for stream-id literals, composite ids and the reserved `All` stream name.
   PLAY0273 as a backstop. Streams `all`, `ALL` and `Default`
   remain valid. Rename via `propose-rename`; a pin retaining `All` cannot fix it.
   Existing `All` history reads as source-only appends, not the renamed stream.
+  Rename a composite part with `propose-rename` too: it rewrites the part and every
+  `part = ...` mapping together and refuses a name that collides with another part;
+  never hand-write a `propose-ast` batch for it (needs a server that supports part
+  renames, see model-authoring `references/mcp-tools.md`).
   Source evidence and migration limits are in that reference.

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

@@ -103,7 +103,7 @@ not the source identity.
 - **Executable** (binds, V3): `references/executable-subset.md`. Optional keyed lookups, unfiltered
   lists and lists narrowed by one `by` key (observable too) bind; caller-supplied equality
   filters on collections bind as ESM v14. Context `from`, single-result
-  filters, opaque `scoped to`/`performer` and a `by` block on a list query remain PLAY0268. Read
+  filters, opaque `scoped to` and a `by` block on a list query remain PLAY0268; a `performer` query is an opaque read left out of the executable model (PLAY0270; [version gate](references/executable-subset.md#code-attachments-what-binds-what-never-does)). Read
   read-surface [equality filters](../cratis-screenplay-read-surface/references/equality-filters.md).
   Pending handlers beside unconditional productions bind as described commands (v23),
   but reached bodies are Unsupported; attached file/inline handlers refuse PLAY0800

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

@@ -8,6 +8,7 @@
 - Explicit enum member numbers
 - Reserved stored names and event pins
 - Named keys, production routes and observer filters
+- Ambiguous match patterns (PLAY0803)
 - Projection event scope (PLAY0801)
 - Reducer instance identity (PLAY0690)
 - Caller identity, compliance and routes
@@ -149,6 +150,14 @@ Overrides/filters select released ESM v10; malformed routes also use PLAY0504.
 Read read-surface `references/named-keys.md` and
 [production routes and filters](production-routes-and-filters.md).
 
+## Ambiguous match patterns (PLAY0803)
+
+Requires Screenplay 4.218.2 (`screenplay --version`); older compilers do not report it.
+
+| Code | Severity | Meaning / fix |
+| --- | --- | --- |
+| PLAY0803 | W | `AmbiguousMatchPattern`: a `matches` pattern in the portable dialect, such as `(a+)+$`, `(a\|a)*` or `(a*)*`, can backtrack exponentially in a browser engine. Reported by both compilers and editors with the ambiguous subexpression; very large patterns are not analyzed. Rewrite it unambiguously (`a+`, `[ab]*`); see command-surface `text-and-match-rules.md`. |
+
 ## Projection event scope (PLAY0801)
 
 Requires Screenplay 4.212.3 (`screenplay --version`) for this ordinary compilation

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

@@ -91,7 +91,7 @@ Requires Screenplay 4.141.0 or later (`screenplay --version`) to bind concept co
   equivalent inferred ESM bytes. Flat composite read-model keys bind as v27
   (see below). Collections and observable delivery bind.
   Caller-supplied equality filters on collections also bind as ESM v14; context
-  sources, single-result filters, scope, performer and a list-query `by` block remain blocked.
+  sources, single-result filters, scope and a list-query `by` block remain blocked; a `performer` query is an opaque read left out of the executable model.
 - One projection per read model: `from`, `every`, `all` (one block per level), `join`,
   `children`, `nested`, `remove with`, `remove via join` (binds; blocks the execution plan at the projection level, see below), `clear with`, counters, `add`,
   `subtract`, `set`, `clear`, variants, and the identifier mapped from the projection's key (`xId = $eventSourceId` only for an event-source key).
@@ -316,11 +316,13 @@ v22–v28 and [described handlers](../../cratis-screenplay-command-surface/refer
 for the result contract. Attached handlers remain unbound.
 
 Inline fences (`csharp`, `typescript`, `react`, `html`, `sql`) and `file <path>` attach
-code to an owner. Three kinds block binding (V3 blocked, no specification runs):
-the attached command `handler` (PLAY0800), the `file` constraint (PLAY0268, see below)
-and a query `performer` (PLAY0268)
-("uses delivery, filtering, scope, or implementation behavior outside the first ESM v1
-vertical"). Everything else binds as an **opaque requirement** that needs a target to
+code to an owner. Two kinds block binding (V3 blocked, no specification runs):
+the attached command `handler` (PLAY0800) and the `file` constraint (PLAY0268, see below).
+A query `performer` does not block: it is an opaque read, reported as information
+`PLAY0270` and left out of the executable model; a specification that reads it is left
+out, and every other specification still runs with `screenplay test`.
+Requires Screenplay 4.220.1 (`screenplay --version`); older versions refuse a performer
+query with PLAY0268 and leave the whole model unbound. Everything else binds as an **opaque requirement** that needs a target to
 execute: reducer transitions, rule predicates, command and concept code validation, policy
 predicates and reaction effects. Reaction effects bind only when the trigger has no
 `reads`; a trigger with `reads` plus a `file` or inline effect fails binding. Reaction
@@ -350,7 +352,7 @@ bodies still leave their owner non-executable.
   code validation is refused (STAGE-ESM-005). Opaque pure policies render.
 - The reference runner returns Unsupported for the opaque bodies that do bind (rule and
   policy predicates, code validation, reducer transitions); a specification that needs one
-  never passes. Attached handlers, file constraints and query performers (and reaction effects on a trigger with
+  never passes. Attached handlers and file constraints (and reaction effects on a trigger with
   `reads`) are different: they leave the whole model unbound, so no specification runs at
   all.
 
@@ -362,7 +364,7 @@ bodies still leave their owner non-executable.
 | Unquoted `import Other.Contract` | PLAY0268 | external contract import is not bound |
 | `pii` or `secret` on a concept | PLAY0268 | Older compilers refuse it outright. Current compilers admit v13 except enum/identity compliance and events mixing personal or explicitly subject-scoped secret values with explicit subject marks; see `compliance.md` in command-surface references |
 | `query` with a `by` block over a list, or `by ... from` context-derived arguments | PLAY0268 | a `by` block binds only on an optional single-instance query (v27). An optional scalar snapshot lookup, an unfiltered list (`RM[]`) and a list narrowed by one caller-supplied `by` key bind, in their `observable` form too |
-| Context `from`, single-result filters, `scoped to`, `performer` queries | PLAY0268 | Typed query context, filtering of single results, opaque scope and query implementation remain unadmitted; each refusal names its reason. Caller-supplied collection equality filters bind as v14. `observable` goes in the return position (`=> observable RM[]`); as a body line it is PLAY0048 |
+| Context `from`, single-result filters, `scoped to` | PLAY0268 | Typed query context, filtering of single results and opaque scope remain unadmitted; a `performer` query is not refused (PLAY0270 information, left out of the executable model); each refusal names its reason. Caller-supplied collection equality filters bind as v14. `observable` goes in the return position (`=> observable RM[]`); as a body line it is PLAY0048 |
 | `contains` or `starts with` in conditions only | PLAY0268 | conditions admit scalar equality (Uuid from v28) and numeric ordering, plus same-primitive command date comparisons from v26; property/concept text rules bind as v24 |
 | Date comparisons with mixed primitives, `$context` (including occurred), `today`, protected read paths, optional condition operands, concept rules or reaction `where` | PLAY0268 | v26 admits only command conditions and command/property literal validation rules |
 | Rule on a nested path (`lines.qty all > 0`) | PLAY0268 | put the rule on the nested value's concept |

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

@@ -53,7 +53,7 @@ This table is a reading of the renderer's admission, not a render result: run th
 | Area | Renders | Refused (code) |
 | --- | --- | --- |
 | Slice kinds | `StateChange`, `StateView`, supported event-triggered `Automation` with Chronicle reactors | Translate, captures, non-event triggers, opaque bodies, clock/trigger/capture specs (`-024`); claim-reading/opaque `runs as` gates (`-034`), mixed effects from one handler (`-037`, redelivery can duplicate events), unsupported conditions/destinations/mappings (`-039`). Keep refused reactions whole |
-| Queries | optional keyed snapshot lookups; snapshot or observable collections, keyed or unkeyed, with v14 equality filters | context/single-result filters, opaque `scoped to`/`performer` and a list-query `by` block: PLAY0268; v27 composite-key lookups by parts: STAGE-ESM-047, read models and projections keyed by parts: STAGE-ESM-048. DateTime filters and required parameters after optional filters refuse `-010`; filter-name collisions refuse `-012`; concept arguments retain Arc validation, including nested members/elements; nullable keys or optional concept filters with `not empty` refuse `-010` rather than changing null behavior |
+| Queries | optional keyed snapshot lookups; snapshot or observable collections, keyed or unkeyed, with v14 equality filters | context/single-result filters, opaque `scoped to` and a list-query `by` block: PLAY0268; a `performer` query is an opaque read (PLAY0270) left out of the model ([version gate](executable-subset.md#code-attachments-what-binds-what-never-does)); v27 composite-key lookups by parts: STAGE-ESM-047, read models and projections keyed by parts: STAGE-ESM-048. DateTime filters and required parameters after optional filters refuse `-010`; filter-name collisions refuse `-012`; concept arguments retain Arc validation, including nested members/elements; nullable keys or optional concept filters with `not empty` refuse `-010` rather than changing null behavior |
 | Authorization | role-only, authenticated, opaque pure policies, claim conditions with Uuid, Date, DateTime or text targets (numeric and Boolean claim matches render as always false), `not`/and/or; roles read through the identity's `RoleClaimType` | role-claim URIs, nested opaque policies, unresolved or non-portable policies, no single identifier, opaque-policy subjects that are not text, Uuid, Date or DateTime (`STAGE-ESM-015`, a restriction separate from declarative claim targets) |
 | Event sources, streams, routes (ESM v8) | rendered, including routed read-model/query companion replay | reserved stored names, unformattable routed fixtures (`STAGE-ESM-030`) |
 | Numbers, case tables | whole numbers as `long` from ESM v8; case tables | out-of-`int` literals below v8 (`STAGE-ESM-031`) |
@@ -99,7 +99,7 @@ ids into routing to fit a renderer (PLAY0515).
   observable collections, including supported equality filters;
   Requires Stage 4.90.0 for snapshot lists and live `IReadModels.Observe` streams;
   older renderers refuse snapshot lists with STAGE-ESM-010.
-  context/single-result filters, opaque `scoped to` and `performer` block binding. Keep a list the domain needs and report
+  context/single-result filters, and opaque `scoped to` block binding; a `performer` query is left out of the executable model ([version gate](executable-subset.md#code-attachments-what-binds-what-never-does)). Keep a list the domain needs and report
   the capability gap; marking it `observable` or keying it is a modeling decision for the user.
 - Attached file/inline handlers refuse PLAY0800 and require constrained implementation
   attachments: gap-fill in code, not by waiting for ESM admission.

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

@@ -3,7 +3,7 @@
 Compiler syntax: `cheat-sheet.md`. Negative capability claims depend on the tool you ran; name it in every verdict.
 
 1. Clean V1 is not executable: binding errors appear through MCP (V2), `render` or `cratis screenplay validate --executable` (bundled compiler, writes nothing). Neither `screenplay <folder>` nor plain `cratis screenplay validate` binds.
-2. The Screenplay samples validate clean but are not all executable; copying their idioms (context-filtered queries, enum/identity compliance, `today`, `reads`, `$causedBy`, templates, performers) can block V3. Caller-supplied collection equality filters bind; read read-surface `references/equality-filters.md`.
+2. The Screenplay samples validate clean but are not all executable; copying their idioms (context-filtered queries, enum/identity compliance, `today`, `reads`, `$causedBy`, templates) can block V3. Caller-supplied collection equality filters bind; read read-surface `references/equality-filters.md`.
 3. Know the target mode (design/executable/renderable) before writing; state it.
 4. Plain `produces` without `for` means allocation in the ESM but "the identifier" in rendered code. Always write `for <identifier>` on a plain `produces <Name>`; inline `produces event <Name>` omits `for` and defaults to the identifier (PLAY0478).
 5. PLAY0029 is a warning: a misspelled keyword (or `type` inside a slice) drops the construct silently. Use `--warnings-as-errors`.

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

@@ -157,7 +157,7 @@ Requires Stage 4.90.0 for snapshot/live lists, 4.96.0 for non-text secrets and 4
 | `STAGE-ESM-005` | Code validation or rule predicate bodies; or a command beyond the first capability (optional event property, event revision other than the first, validation or requirement that cannot be rendered, neither `produces` nor a response) | Use declarative validation; non-initial event generations are not rendered |
 | `STAGE-ESM-006` | `produces` that cannot render without changing its destination or mappings (expression/enum conditions, literal or computed mappings, `for` not a command identifier, mappings not one-to-one with event properties, duplicate tags) | Map properties one to one; supported conditional productions render as guarded events, not separate commands |
 | `STAGE-ESM-007`, `-008`, `-009` | Projection count per read model (exactly one projection or reducer each); unresolvable properties or no single read-model transition (**flat** projections only); affected instance not one, not keyed by an event property, or not the event-source identity (flat projections only) | One projection per read model; see "Projections" below |
-| `STAGE-ESM-010` | A query is neither an optional snapshot lookup by the read-model identifier nor a supported snapshot/observable collection query; each query is checked on its own. Both collection modes render. Concept-typed keys and filters retain Arc validation, including composite members and collection elements; nullable concept keys or optional concept filters with `not empty` cannot preserve null semantics | Keyed `XById => X optional` queries or snapshot/observable lists. Equality filters render on both collections; DateTime filters, required filters after optional ones and unsupported null-validation shapes refuse 010. Filter-name collisions refuse 012. Context/single-result filters, opaque scope/performer and a list-query `by` block remain PLAY0268; a read model with several key parts (v27) refuses `STAGE-ESM-048` |
+| `STAGE-ESM-010` | A query is neither an optional snapshot lookup by the read-model identifier nor a supported snapshot/observable collection query; each query is checked on its own. Both collection modes render. Concept-typed keys and filters retain Arc validation, including composite members and collection elements; nullable concept keys or optional concept filters with `not empty` cannot preserve null semantics | Keyed `XById => X optional` queries or snapshot/observable lists. Equality filters render on both collections; DateTime filters, required filters after optional ones and unsupported null-validation shapes refuse 010. Filter-name collisions refuse 012. Context/single-result filters, opaque scope and a list-query `by` block remain PLAY0268; a performer query is left out of the model (PLAY0270, Requires Screenplay 4.220.1), so render emits nothing for it and it is a gap-fill item; a read model with several key parts (v27) refuses `STAGE-ESM-048` |
 | `STAGE-ESM-011` | A specification cannot render (see the rules below) | Reshape it only if the assertion keeps its meaning; otherwise keep the specification, record the gap, and gap-fill with the specification as the oracle. Never weaken or delete it to get a render |
 | `STAGE-ESM-012` | Generated C# names collide (properties, types, namespaces, constraints) | Rename |
 | `STAGE-ESM-013` | An event-context value other than `$context.occurred` mapped in `produces` | Map a command property when that preserves the meaning; otherwise gap-fill |

package/package/profile-catalog.json

@@ -657,6 +657,7 @@
       "availableTargets": [
         "cratis-content-length",
         "cratis-developer-marketing",
+        "cratis-discoverability",
         "cratis-release-notes",
         "cratis-social-feed-post",
         "cratis-technical-examples",
@@ -670,6 +671,7 @@
     {
       "id": "cratis/documentation",
       "availableTargets": [
+        "cratis-discoverability",
         "cratis-documentation-writing",
         "cratis-engineering-docs-authoring",
         "cratis-llm-friendly-documentation",

package/package.json

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