@cratis/pi 7.36.0 → 7.37.0

package/package/corpus/hooks/scripts/cratis-nuget-pins.txt

@@ -8,5 +8,11 @@ Cratis.Arc.Chronicle 22.75.0
 Cratis.Chronicle 19.50.1
 Cratis.Chronicle.CodeAnalysis 19.50.1
 Cratis.Fundamentals 7.23.0
+Cratis.Metrics.Roslyn 7.23.0
+Cratis.OpenTelemetry 7.23.0
+Cratis.Orleans 1.16.3
+Cratis.Orleans.Chronicle 1.16.3
+Cratis.Orleans.Storage.MongoDB 1.16.3
+Cratis.Orleans.Storage.Sql 1.16.3
 Cratis.Specifications 4.1.1
 Cratis.Specifications.XUnit 4.1.1

package/package/corpus/product-sync.json

@@ -230,7 +230,8 @@
       },
       "covers": {
         "skills": [
-          "cratis-chronicle-hosting"
+          "cratis-chronicle-hosting",
+          "cratis-orleans-jobs"
         ],
         "rules": [
           "orleans.md"
@@ -384,6 +385,7 @@
           "cratis-code-review",
           "cratis-engineering-csharp-conventions",
           "cratis-fundamentals-concept",
+          "cratis-fundamentals-telemetry",
           "cratis-fundamentals-type-discovery"
         ],
         "rules": [
@@ -411,6 +413,8 @@
         "skills": [
           "cratis-arc-react-page",
           "cratis-components-accessibility",
+          "cratis-components-common-controls",
+          "cratis-components-data-surfaces",
           "cratis-components-schema-editor",
           "cratis-components-stepper-command-dialog",
           "cratis-components-styling",

package/package/corpus/rules/orleans.md

@@ -43,6 +43,10 @@ in its resilient storage pipeline.
 
 ## Co-host a silo with Cratis.Orleans
 
+For job/step authoring, stage barriers, recovery, storage scopes and state-machine
+APIs, load **cratis-orleans-jobs** from `cratis/engineering/csharp`. These APIs are
+framework/service guidance; they do not impose application slice architecture.
+
 For service authors, `Cratis.Orleans` supplies hosting, grain serializers, and the
 shared job system without requiring Chronicle. With `Cratis.Orleans` and
 `Cratis.Orleans.Storage.MongoDB` 1.16.3, this host uses durable MongoDB membership

package/package/corpus/rules/profiles.md

@@ -73,8 +73,8 @@ profile includes neither Screenplay nor Stage.
 |---|---|---|
 | `cratis/arc` | Arc CQRS framework | `cratis/arc/csharp`, `cratis/arc/java`, `cratis/arc/kotlin` |
 | `cratis/chronicle` | Chronicle event sourcing engine (does not compose `cratis/chronicle/mcp`) | `cratis/chronicle/compliance`, `cratis/chronicle/csharp`, `cratis/chronicle/elixir`, `cratis/chronicle/java`, `cratis/chronicle/kotlin`, `cratis/chronicle/multi-tenancy`, `cratis/chronicle/typescript`, `cratis/chronicle/web-workbench` |
-| `cratis/components` | React component library | (no child profiles) |
-| `cratis/fundamentals` | Core primitives (`ConceptAs<T>`, `EventSourceId<T>`) | (no child profiles) |
+| `cratis/components` | React component library, including `cratis-components-common-controls` and `cratis-components-data-surfaces` | (no child profiles) |
+| `cratis/fundamentals` | Core primitives and generated .NET telemetry (`cratis-fundamentals-telemetry`) | (no child profiles) |
 | `cratis/arc/go` | Experimental Arc.Go HTTP CQRS (root module) | `cratis/language/go`, `cratis/fundamentals/go` |
 | `cratis/chronicle/client-go` | Experimental standalone Chronicle.Go client | `cratis/language/go`, `cratis/fundamentals/go` |
 | `cratis/fundamentals/go` | Fundamentals.Go named scalar concepts and codecs | `cratis/language/go` |
@@ -86,7 +86,7 @@ profile includes neither Screenplay nor Stage.
 | Profile ID | Description | Automatically Includes |
 |---|---|---|
 | `cratis/engineering` | Engineering conventions and workflows | `cratis/engineering/core`, `cratis/engineering/csharp`, `cratis/engineering/elixir`, `cratis/engineering/go`, `cratis/engineering/kotlin`, `cratis/engineering/react`, `cratis/engineering/typescript` |
-| `cratis/engineering/csharp` | C# engineering conventions | `cratis/engineering/core` |
+| `cratis/engineering/csharp` | C# engineering conventions and framework Orleans jobs (`cratis-orleans-jobs`, alongside `orleans.md`) | `cratis/engineering/core` |
 | `cratis/engineering/go` | Go framework parity and immutable module releases | `cratis/engineering/core`, `cratis/language/go` |
 | `cratis/engineering/typescript` | TypeScript engineering conventions | `cratis/engineering/core` |
 | `cratis/engineering/react` | React engineering conventions | `cratis/engineering/core` |

package/package/corpus/skills/cratis-arc-observable-query-http/SKILL.md

@@ -136,6 +136,23 @@ Sources at v22.75.0: `Arc.Core/Queries/ObservableQueryHttp.cs`,
 `ObservableQueryHandler.cs` and
 [MongoDB observations](https://github.com/Cratis/Arc/blob/v22.75.0/Documentation/backend/csharp/mongodb/observing-collections.md).
 
+### Local `cratis` template ports
+
+Templates `v1.7.4` still publishes MongoDB on host port `27017` and configures
+`mongodb://localhost:27017` for the app (`Templates/Cratis/docker-compose.yml:3–13`,
+`appsettings.json:35–37`). Its Vite dev server runs on `9000` and proxies `/api`,
+`/.cratis` and `/swagger` to `http://localhost:5000`
+(`Templates/Cratis/.frontend/vite.config.ts:24–39`). A backend started on another
+port needs matching proxy targets; a healthy Chronicle container alone does not
+prove the browser can reach the app or its MongoDB read models.
+
+The bundled development MongoDB replica set advertises `localhost:27017`
+(Chronicle `v19.34.0`, `Docker/entrypoint.sh:23–25`). For that setup, merely changing
+Docker's host mapping to another port does not change the advertised member
+address. Keep `27017` available, or deliberately reconfigure the replica set and
+application connection together. These are local template defaults, not Arc
+requirements or production topology advice.
+
 ## What comes back
 
 Every transport carries the same `QueryResult` shape:

package/package/corpus/skills/cratis-arc-observable-query-http/verification.json

@@ -0,0 +1,12 @@
+{
+  "skill": "cratis-arc-observable-query-http",
+  "input": "Our local cratis template query is stuck Loading after changing the MongoDB and backend host ports. Which connections should we check?",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "Templates `v1.7.4`" },
+    { "kind": "skill-contains", "value": "mongodb://localhost:27017" },
+    { "kind": "skill-contains", "value": "http://localhost:5000" },
+    { "kind": "skill-contains", "value": "does not change the advertised member" },
+    { "kind": "skill-contains", "value": "local template defaults, not Arc" }
+  ]
+}

package/package/corpus/skills/cratis-arc-react-page/SKILL.md

@@ -71,7 +71,11 @@ must move focus into itself.
   `@cratis/components`) above every Cratis component — it carries the locale,
   the Components-owned labels. Enable `toaster` (or mount one `<Toaster />`)
   for notifications; without it even `toastCommandResult` displays nothing.
-  Mount exactly one toaster, not both.
+  Mount exactly one toaster, not both. The `cratis` template already mounts
+  `<CratisComponentsProvider toaster>` **inside** `<Arc>` at Templates `v1.7.4`
+  (`Templates/Cratis/.frontend/main.tsx:12–19`); the missing-toaster/outside-Arc
+  workaround for `v1.7.2` no longer applies to that template version. Check an
+  older application's entry point rather than adding a second toaster.
 - The app must import the stylesheets explicitly; components do not import
   their own CSS:
 

package/package/corpus/skills/cratis-arc-react-page/verification.json

@@ -12,6 +12,9 @@
     },
     { "kind": "skill-contains", "value": "DataPage has no snapshot refresh handle" },
     { "kind": "skill-contains", "value": "Mount exactly one toaster" },
+    { "kind": "skill-contains", "value": "<CratisComponentsProvider toaster>" },
+    { "kind": "skill-contains", "value": "Templates `v1.7.4`" },
+    { "kind": "skill-contains", "value": "rather than adding a second toaster" },
     { "kind": "skill-contains", "value": "4.26.4" },
     { "kind": "skill-contains", "value": "checkbox multi-selection", "file": "references/data-tables.md" },
     { "kind": "skill-contains", "value": "DataPage never invokes it or refetches", "file": "references/data-page.md" }

package/package/corpus/skills/cratis-chronicle-client-kotlin/SKILL.md

@@ -247,8 +247,8 @@ store.eventLog.transactional.appendMany("<id>", listOf(<OtherEvent>()))
 unitOfWork.commit()
 ```
 
-`transactional` appends return `Unit`, not an `AppendResult`; the results are on
-the unit of work (`transactions/IUnitOfWork.kt:23-101`).
+In a unit of work, `transactional` appends return a placeholder `AppendResult`
+(sequence `-1`); real results are on the unit of work after `commit()`.
 
 ## Observing
 

package/package/corpus/skills/cratis-components-common-controls/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: cratis-components-common-controls
+description: Choose and bind Cratis Components ComboBox, ToggleGroup, Tabs, TagGroup and Breadcrumbs with controlled values, query states, keyboard semantics and localizable names. Use for entity pickers, exclusive choices, panel tabs, tag inputs or navigation trails. Do not use for Arc generated command fields, data tables, canvas palettes or theming.
+license: MIT
+---
+
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Common controlled controls
+
+## Verified product sources
+
+All claims and prop shapes are from **Cratis/Components v4.26.4**, source rather than unversioned examples.
+
+| Package | Version | Sources |
+| --- | --- | --- |
+| `@cratis/components` | `4.26.4` | `Source/Common/ComboBox.tsx:44-161,223-295`; `ToggleGroup.tsx:21-87,109-145`; `Tabs.tsx:23-79,91-132`; `TagGroup.tsx:49-145,155-260`; `Breadcrumbs.tsx:23-61,81-126` |
+| React | `^19.0.0` peer | `Source/package.json:319-340` |
+
+Imports are exported by `Source/Common/index.ts:11-15`; `Source/package.json:95-99` exposes the `Common` subpath. Use **cratis-components-styling** for the provider and CSS setup and **cratis-components-accessibility** for naming/focus. These controls do not replace Arc's generated `InputTextField`/other command fields; use **cratis-arc-react-page** for those bindings.
+
+## Choose the semantic control first
+
+| Need | Control | Controlled contract |
+| --- | --- | --- |
+| Pick one option, with search | `ComboBox` | `options: { key, label, description?, disabled? }[]`, `value: string \| null`, `onChange(key)` |
+| Choose one value from a small set | `ToggleGroup` | `options: { value, label, icon?, disabled? }[]`, `value: string`, `onChange(value)` |
+| Reveal a corresponding content panel | `Tabs` | `tabs: { id, label, content, disabled? }[]`, `value: string`, `onChange(id)` |
+| Add/remove string values | `TagGroup` | `value: string[]`, `onChange(nextValues)` |
+| Show where the page sits in navigation | `Breadcrumbs` | `items: { label, href?, onNavigate? }[]`, outermost first |
+
+`ToggleGroup` is a single-selection value choice with radio-group semantics and one Tab stop. `Tabs` supplies real panels and tab/panel relationships. Do not use panel-less tabs as a fancy radio group (`ToggleGroup.tsx:78-87`, `Tabs.tsx:70-79`).
+
+## 1. Bind a picker, not its display text
+
+A controlled presentation component; the caller owns the selected key and supplies approved/localized text. `inputValue` is a separate search draft, not the selected value.
+
+```tsx
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ComboBox, type ComboBoxOption } from '@cratis/components/Common';
+
+interface AccountPickerProps {
+    options: ComboBoxOption[];
+    value: string | null;
+    onChange: (key: string | null) => void;
+    label: string;
+    loading: boolean;
+    loadingMessage: string;
+    emptyMessage: string;
+}
+
+export const AccountPicker = (props: AccountPickerProps) => (
+    <ComboBox
+        options={props.options}
+        value={props.value}
+        onChange={props.onChange}
+        aria-label={props.label}
+        loading={props.loading}
+        loadingMessage={props.loadingMessage}
+        emptyMessage={props.emptyMessage}
+        openOnFocus
+    />
+);
+```
+
+The host loads options; ComboBox never fetches them. For server-filtered results, supply `inputValue`, `onInputChange` and `filter='none'`; the caller debounces/cancels requests and discards stale answers. Local `filter` defaults to `'contains'`; `'startsWith'` is also supported. Explicit open/focus shows all options rather than filtering to the selected label (`ComboBox.tsx:170-177,223-266`).
+
+Useful props (`:106-161`):
+
+- `failure: ReactNode` replaces options with failure content. `loading` shows `loadingMessage`; `emptyMessage` is for a genuine empty result. Do not map denied/failed loads to an empty list without an explanation.
+- `optionLayout='inline' | 'stacked'` controls secondary `description` placement.
+- `action={{ label, onAction }}` offers a footer action receiving the current input text. It **does not select or create an option for you**. The handler may return a promise, but the component fires it without awaiting; the caller owns busy/error handling (`:268-287`).
+- `required`, `invalid`, `errorMessage`, `description`, `disabled`, `readOnly`, `name` and `id` cover field state. `id` belongs to the input for `<label htmlFor>`. `name` carries the selected key, not search text (`:133-156`).
+
+## 2. Choose a value or a panel
+
+JSX binding excerpts inside an existing view. They assume caller-owned string values, change callbacks, and localized `labels` with the named properties:
+
+```tsx
+import { ToggleGroup, Tabs } from '@cratis/components/Common';
+
+<ToggleGroup
+    aria-label={labels.viewMode}
+    value={viewMode}
+    onChange={changeViewMode}
+    options={[
+        { value: 'compact', label: labels.compact },
+        { value: 'expanded', label: labels.expanded }
+    ]}
+/>
+
+<Tabs
+    aria-label={labels.details}
+    value={selectedTab}
+    onChange={changeTab}
+    tabs={[
+        { id: 'overview', label: labels.overview, content: overview },
+        { id: 'history', label: labels.history, content: history }
+    ]}
+/>
+```
+
+`ToggleGroup.onChange` receives a string, not a DOM event; selecting the already-selected value is ignored. `Tabs.onChange` also receives an ID string. Both offer `disabled`, accessible labeling, `className` and typed `pt` parts. ToggleGroup additionally exposes `invalid` and `aria-describedby` (`ToggleGroup.tsx:52-76,116-121`; `Tabs.tsx:51-68`). Do not infer route navigation from changing a tab; its job is revealing content.
+
+## 3. Add tags without confusing display with read-only
+
+JSX excerpt in a view with caller-owned `tags: string[]`, `changeTags`, and localized labels:
+
+```tsx
+import { TagGroup } from '@cratis/components/Common';
+
+<TagGroup
+    aria-label={labels.tags}
+    value={tags}
+    onChange={changeTags}
+    separators={[',', ';']}
+    removeLabel={tag => labels.removeTag.replace('{tag}', tag)}
+/>
+```
+
+TagGroup defaults to `editable=true`, comma separators and `allowDuplicates=false`. Enter or separators commit trimmed nonempty values; paste splits on separators. Empty-entry Backspace removes the last tag (`TagGroup.tsx:94-109,127-145,190-260`).
+
+**`editable=false` only removes the adding input; existing tags remain removable.** Use `disabled` when removal must also be unavailable, or a display-only surface for noninteractive tags. Supply `removeLabel(value)` for localized accessible names. `removeIcon` overrides that group's glyph (ahead of provider `icons.remove`) without changing the button's name or keyboard behavior (`TagGroup.tsx:54-91,155-190`). Prefer unique values: removal is value-keyed, so this is not an identity-preserving collection editor (`:139-140`).
+
+## 4. Build the breadcrumb trail from actual navigation
+
+JSX excerpt in a view whose `labels` are localized:
+
+```tsx
+import { Breadcrumbs } from '@cratis/components/Common';
+
+<Breadcrumbs
+    aria-label={labels.location}
+    items={[
+        { label: labels.home, href: '/' },
+        { label: labels.accounts, href: '/accounts' },
+        { label: labels.currentAccount }
+    ]}
+/>
+```
+
+Earlier entries can supply `href` or router-owned `onNavigate`. The last item is current: its destination/callback is suppressed and React Aria supplies `aria-current='page'`. Separators are decorative; `separator` accepts any React node (`Breadcrumbs.tsx:97-126`). Supply a distinct landmark name if a page has multiple trails. Breadcrumbs do not discover routes or enforce access.
+
+## Verify the binding
+
+Test caller state changes using the real payload shapes (key/string/string array), not invented `{ value }` events. Exercise null selection, query failure, disabled options, panel content, tag removal and the final breadcrumb. Browser-check keyboard/focus and accessible names. `pt` keys belong to each exported `*Parts` interface; style those parts rather than overriding internal React Aria markup. Do not add undocumented props to work around a failed interaction.

package/package/corpus/skills/cratis-components-common-controls/verification.json

@@ -0,0 +1,15 @@
+{
+  "skill": "cratis-components-common-controls",
+  "input": "Choose between a value toggle and panel tabs, wire a nullable entity picker and disable tag editing correctly.",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "@cratis/components/Common" },
+    { "kind": "skill-contains", "value": "ComboBoxOption" },
+    { "kind": "skill-contains", "value": "inputValue" },
+    { "kind": "skill-contains", "value": "radio-group semantics" },
+    { "kind": "skill-contains", "value": "content: overview" },
+    { "kind": "skill-contains", "value": "existing tags remain removable" },
+    { "kind": "skill-contains", "value": "removeLabel" },
+    { "kind": "skill-contains", "value": "aria-current='page'" }
+  ]
+}

package/package/corpus/skills/cratis-components-data-surfaces/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: cratis-components-data-surfaces
+description: Compose Cratis Components PivotViewer exploration, TimeMachine historical snapshots, Canvas pan/zoom boards and public Chat conversation/sidebar surfaces. Use when a table is not the right presentation, when supplying Pixi-backed content, or when binding host-owned chat data and actions. Do not use for DataPage lists, backend event replay, chat persistence, canvas tool palettes or Scene authoring.
+license: MIT
+---
+
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Data beyond a table
+
+## Verified product sources
+
+All API and behavior claims below use **Cratis/Components v4.26.4**.
+
+| Package | Version | Source |
+| --- | --- | --- |
+| `@cratis/components` | `4.26.4` | `Source/PivotViewer/types.ts:67-112,145-187`; `Source/TimeMachine/{TimeMachine.tsx:19-65,types.ts:8-34}`; `Source/Canvas/{Canvas.tsx:38-104,CanvasItem.tsx:8-38,CanvasHandle.ts:7-21}`; `Source/Chat/{index.ts:4-40,ChatConversation.tsx:78-180,ChatSidebar.tsx:86-203}` |
+| `pixi.js` | `^8.20.0` optional peer | `Source/package.json:319-340`; required when using Canvas or PivotViewer |
+| React | `^19.0.0` peer | `Source/package.json:319-340` |
+
+Subpath exports: `Source/package.json:60-69,155-159,178-182`; each area's `index.ts` exports the types used below. Load **cratis-components-styling** for CSS/provider setup and **cratis-components-accessibility** for localized names. For tabular queries use **cratis-arc-react-page**; for a board tool palette use **cratis-components-toolbar**.
+
+These are **presentation contracts**. The host owns loading, access control, data acquisition and persistence. A historical slider is not event replay; a chat send callback is not a durable write.
+
+## Choose the surface
+
+| Surface | Fit | Avoid assuming |
+| --- | --- | --- |
+| `PivotViewer` | Faceted card exploration of an already-loaded collection | Server paging, JSX card rendering or controlled selection |
+| `TimeMachine` | Supplied historical snapshots and event descriptions | Fetching history, rebuilding a read model or a controlled current index |
+| `Canvas` | A pan/zoom board combining DOM items and optional Pixi objects | That moving the camera persists item positions |
+| `ChatConversation` / `ChatSidebar` | Host-owned messages, topic selection and actions | Automatic message persistence, authorization or topic naming |
+
+Keep Canvas/PivotViewer behind their subpath imports so ordinary pages do not acquire a Pixi import edge. Install/deduplicate the optional `pixi.js` peer for these areas, including a DOM-only Canvas: `Canvas.tsx:176` initializes Pixi through `usePixiApplication`. Do not rely on the word "optional" to omit it when importing those areas.
+
+## 1. PivotViewer: data and text cards, not React cards
+
+`data`, `dimensions` and `cardRenderer` are required. Each dimension has `key`, `label`, `getValue`; optional `formatValue` and `sort` control group presentation. **`cardRenderer` returns structured text, not JSX**. `detailRenderer(item, onClose)` may return a React node (`PivotViewer/types.ts:67-78,145-163`).
+
+This component accepts loaded domain data; its labels come from the host's localization layer:
+
+```tsx
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PivotViewer } from '@cratis/components/PivotViewer';
+
+interface CatalogItem {
+    id: string;
+    name: string;
+    category: string;
+}
+
+interface CatalogExplorerProps {
+    items: CatalogItem[];
+    categoryLabel: string;
+    loadingLabel: string;
+    isLoading: boolean;
+}
+
+export const CatalogExplorer = (props: CatalogExplorerProps) => (
+    <PivotViewer<CatalogItem>
+        data={props.items}
+        dimensions={[{ key: 'category', label: props.categoryLabel, getValue: item => item.category }]}
+        getItemId={item => item.id}
+        cardRenderer={item => ({ title: item.name, values: [item.category] })}
+        searchFields={[item => item.name]}
+        isLoading={props.isLoading}
+        loadingLabel={props.loadingLabel}
+    />
+);
+```
+
+Other substantial props (`types.ts:93-112,145-185`):
+
+- `filters` accepts keyed facets with `label` and `getValue`. Optional `options` are `{ key, label, value, count }`; otherwise they are computed from data. Numeric `type='number'` supports a range/histogram with `buckets`; `renderEditor` replaces a facet editor.
+- `defaultDimensionKey` initializes grouping. Group/filter/selection state is internal; there is no `selectedItem`/`onSelectedItemChange` prop at this tag (`PivotViewer.tsx:54-112`).
+- `searchFields` are property accessors. Use direct property paths, not computed expressions: the implementation extracts paths from accessor source (`types.ts:23-29`, `utils/search.ts`).
+- `emptyContent`, `isLoading`, `loadingLabel`, `labels` and `colors` control presentation. Use the exported `PivotViewerLabels` shape for localization; do not put DOM markup in a text-card result.
+
+Bound the dataset in the host. A worker and virtualized rendering do not make loading an unbounded collection a safe query shape (`PivotViewer.tsx:152-165`). Test actual browser rendering, resizing, zoom and keyboard behavior; a server-rendered shell does not exercise Pixi.
+
+## 2. TimeMachine: prepare history before rendering
+
+`Version` is `{ id: string, timestamp: Date, label: string, content: ReactNode, events?: Event[] }`. `Event` is `{ sequenceNumber: number, type: string, occurred: Date, content: Record<string, unknown> }`; it is a presentation DTO, not a Chronicle client object (`TimeMachine/types.ts:8-34`). Supply versions in the intended history order.
+
+Binding excerpt for an existing view with `versions: Version[]`, a caller-owned `onVersionSelected(index)` callback and translated `timelineLabels: Partial<TimeMachineLabels>`:
+
+```tsx
+import { TimeMachine } from '@cratis/components/TimeMachine';
+
+<TimeMachine
+    versions={versions}
+    currentVersionIndex={0}
+    onVersionChange={onVersionSelected}
+    labels={timelineLabels}
+/>
+```
+
+**`currentVersionIndex` is initial-only**. Later prop changes do not replace internal selection. `onVersionChange(index)` reports timeline/wheel/previous/next selection; `scrollSensitivity` defaults to 50. The component offers read-model and event views over supplied data (`TimeMachine.tsx:19-65,73-125,133-145`). Do not promise an externally controlled scrubber or backend replay.
+
+Load only authorized, redacted history. The presence of an event payload in this display is not permission to reveal it, and snapshot content is host-supplied React content. Exercise both modes and localization with the real DTOs.
+
+## 3. Canvas: distinguish camera, DOM items and Pixi data
+
+DOM content belongs in `Canvas` children. Position measured items with `CanvasItem x/y`, optional stable `id`, and optional `zIndex` on the item root (nested z-index cannot escape its stacking context). The item registry feeds minimap measurements (`CanvasItem.tsx:8-42,65-95`).
+
+```tsx
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Canvas, CanvasItem } from '@cratis/components/Canvas';
+
+export const Board = () => (
+    <Canvas style={{ height: '32rem' }} showMinimap minimapWorldWidth={1600} minimapWorldHeight={1200}>
+        <CanvasItem id='first-card' x={100} y={80}>
+            <article>First card</article>
+        </CanvasItem>
+    </Canvas>
+);
+```
+
+The literal card text is illustrative; use the host's approved/localized content. Give the board visible dimensions. For Pixi items, supply `items: T[]` extending `CanvasItemData` and `renderItem(item): PIXI.Container`; `onItemPointerDown` reports item activation, `onReady` receives `CanvasContext` (`Canvas.tsx:38-50`). Do not return React nodes from `renderItem`.
+
+Camera/controls contract (`Canvas.tsx:51-104,119-160`, `CanvasHandle.ts:7-21`):
+
+- `initialZoom` and `initialPan` are initial values, not a controlled camera. `onTransformChange(zoom, pan)` reports movement. Use `onHandleReady` and `CanvasHandle.smoothPanToWorld`/`smoothPanZoomToWorld` for navigation; `getContainerRect` and `getItemBounds` measure it.
+- `minZoom`/`maxZoom` default to 0.1/5. `showControls` defaults true; `showMinimap` false. `minimapItems` can replace registry-derived rectangles.
+- `controlsPlacement` is `'bottom-left' | 'bottom-right'`; `controlsLabels` and `controlsIcons` are typed override objects. `controlsFollowViewportInsets` defaults true, stepping aside by `--canvas-viewport-left/right`. Set false when the host already offsets the whole canvas, or the inset is applied twice.
+- `readOnly` absorbs content interaction but leaves pan/zoom available. `backgroundDragPans=false` lets a product own background drag selection while wheel/middle-button/touch panning remain available.
+
+Persist item edits in the host, not in camera callbacks. Browser-test gestures and dimensions. For jsdom tests provide a `ResizeObserver` substitute where required; Pixi integration still needs a real browser signal.
+
+## 4. Public Chat: bind the host's messages and outcomes
+
+The public `@cratis/components/Chat` exports **`ChatConversation`**, **`ChatSidebar`**, **`ChatSidebarForObservableQueries`**, **`ChatTopicList`** and their types. It does **not** export the Kit `Chat` component or expose a `Chat/Kit` package subpath (`Source/Chat/index.ts:4-40`, `Source/package.json`). **`Chat` is exported through `@cratis/components/Canvas`** via the Kit barrel (`Source/Canvas/index.ts:37-40`, `Source/Chat/Kit/index.ts:4-26`). Prefer the non-spatial Chat subpath for ordinary host-data conversations; importing Canvas brings its Pixi edge.
+
+The Kit `Chat` has a different contract: required `messages`, `onSend(text)` and `onClose`; optional `variant`, `typingAuthors`, `currentUserId`, `onReact(messageId, emoji)`, `onAct(messageId)`, `canAct` and nested `labels`. Its messages use the Kit `ChatMessage` shape, not the public Chat subpath's message type. Reactions need both `currentUserId` and `onReact`. An optional `id` additionally publishes `ChatMessageAdded` over an available Arc messenger at send time, not after persistence succeeds (`Source/Chat/Kit/Chat.tsx:58-135`, `ChatMessage.ts`). Never count that notification as durable delivery, or mix `onSend` with the public conversation's `onSendMessage`.
+
+The public `ChatMessage` has `id`, `topicId`, `authorId`, `body`, `timestamp: Date`, optional `mentions` and `metadata`. Identifiers use `ChatIdentifier`; resolve authors through `authorOf`, not an invented `authorName` property (`ChatMessage.ts:17-37`, `ChatConversation.tsx:78-127`).
+
+Complete presentation wrapper using the real public types:
+
+```tsx
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import {
+    ChatConversation, ChatStatus,
+    type ChatConversationLabels, type ChatMention, type ChatMessage
+} from '@cratis/components/Chat';
+
+interface ConversationProps {
+    messages: ChatMessage[];
+    status: ChatStatus;
+    labels: ChatConversationLabels;
+    send: (body: string, mentions: ChatMention[]) => void;
+}
+
+export const Conversation = (props: ConversationProps) => (
+    <ChatConversation
+        messages={props.messages}
+        status={props.status}
+        labels={props.labels}
+        onSendMessage={props.send}
+    />
+);
+```
+
+`onSendMessage` reports the trimmed body and mentions; persistence is the host's responsibility. Supply fresh authorized data after command success. Handle failure visibly rather than adding a fabricated message that looks saved.
+
+`ChatStatus.Ready/Loading/Failed/Unauthorized` distinguish query outcomes. Existing messages remain during loading/failure; unauthorized replaces them and disables the composer (`ChatStatus.ts:5-14`, `ChatConversation.tsx:85`). This is UI behavior, not backend enforcement.
+
+Additional public contracts:
+
+- `actions` are typed `ChatMessageAction<TMessage>[]`; `renderMessageExtra(message)` supplies reaction/failure/detail content under the body. `mentionCandidates` or `resolveMentionCandidates` supplies available mentions (`ChatConversation.tsx:121-180`).
+- `ChatSidebar` requires `open`, `onClose`, `topics`, `messages`, and `onSendMessage(topicId, body, mentions)`. `topicActions` is separate from inherited message `actions`; `renderHeaderActions(openTopic)` belongs to the sidebar (`ChatSidebar.tsx:86-163`).
+- `selectedTopicId` is controlled when provided: ID opens a topic, null shows the list, omission uses internal selection. `onTopicSelected` reports selection. `topicsStatus` and `messagesStatus` are separate; do not show one topic's cached messages while another topic is loading (`:123-142`).
+- `onStartTopic` returns a created identifier or undefined, optionally in a promise. `onRequestTopicName` asks the host to name an unnamed topic after its first message. Neither creates/saves/names anything on its own (`:144-180`).
+- The sidebar defaults non-modal, right edge, `24rem`; `position`, `width`, `modal`, `labels`, and typed `pt` customize it (`:182-203`).
+
+## Verify the surface, not only the props
+
+Test host orchestration separately from Components: loading/failed/denied vs empty, stable IDs, data ordering, and persistence errors. Browser-check interaction/focus and all visible/localized labels. Do not infer remote fetch, tenant isolation, history reconstruction or message delivery from a rendered surface or a passing type check.

package/package/corpus/skills/cratis-components-data-surfaces/verification.json

@@ -0,0 +1,16 @@
+{
+  "skill": "cratis-components-data-surfaces",
+  "input": "Present loaded faceted data, history snapshots, a pan/zoom board and host-owned chat without inventing persistence.",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "cardRenderer` returns structured text, not JSX" },
+    { "kind": "skill-contains", "value": "currentVersionIndex` is initial-only" },
+    { "kind": "skill-contains", "value": "CanvasItem" },
+    { "kind": "skill-contains", "value": "controlsFollowViewportInsets" },
+    { "kind": "skill-contains", "value": "pixi.js" },
+    { "kind": "skill-contains", "value": "Chat` is exported through `@cratis/components/Canvas`" },
+    { "kind": "skill-contains", "value": "onSendMessage" },
+    { "kind": "skill-contains", "value": "renderHeaderActions(openTopic)" },
+    { "kind": "skill-contains", "value": "not backend enforcement" }
+  ]
+}

package/package/corpus/skills/cratis-fundamentals-telemetry/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: cratis-fundamentals-telemetry
+description: Instrument a .NET service with Cratis.Metrics.Roslyn generated counters, gauges, histograms and spans, and subscribe/export them through Cratis.OpenTelemetry. Use for partial instrumentation declarations, missing telemetry, host setup or metric-name upgrades. Do not use for operating a collector or for application audit records.
+license: MIT
+---
+
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Generated metrics and traces
+
+Use this when a service needs measurements and spans, not business facts. Keep event sourcing and audit records separate from telemetry.
+
+## Verified product sources
+
+All source locators below are in **Cratis/Fundamentals v7.23.0**. Read the tag, not a sibling checkout's HEAD.
+
+| Package | Version | Source |
+| --- | --- | --- |
+| `Cratis.Fundamentals` | `7.23.0` | `Source/DotNET/Fundamentals/Metrics/{Counter,Gauge,Histogram}Attribute.cs`, `Traces/SpanAttribute.cs`, `Diagnostics/TagAttribute.cs` |
+| `Cratis.Metrics.Roslyn` | `7.23.0` | `Source/DotNET/Metrics.Roslyn/MetricsSourceGenerator.cs:42-130,174-238,285-337,354-406`; `Templates/Metrics.hbs:11-123` |
+| `Cratis.OpenTelemetry` | `7.23.0` | `Source/DotNET/OpenTelemetry/OpenTelemetryExtensions.cs:29-180,215-315`; `InstrumentationExtensions.cs:17-31`; `CratisOpenTelemetryOptions.cs:19-34` |
+
+Registration evidence: `Source/DotNET/Fundamentals/DependencyInjection/ServiceCollectionExtensions.cs:27-54`. Unkeyed names: `Metrics/UnkeyedMeter.cs:17-23`, `Traces/UnkeyedActivitySource.cs:17-23` under the same Fundamentals source root. Upgrade context: `Documentation/csharp/metrics/roslyn.md` (Exported Metric Names) and `Documentation/csharp/opentelemetry.md`.
+
+## 1. Declare instrumentation beside its owner
+
+Reference `Cratis.Fundamentals` for runtime types and `Cratis.Metrics.Roslyn` for generation. Use a **static partial class in a namespace**, containing **static partial methods**. The generator's candidate filter requires static classes even for metrics; a merely partial instance class is not enough (`MetricsSourceGenerator.cs:42-53,84-93`). Prefer extension declarations with short, unqualified attribute/type names, as below.
+
+This declaration file is complete; it assumes the application's existing `ReportWorker` class in `MyApplication.Reports`:
+
+```csharp
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using Cratis.Diagnostics;
+using Cratis.Metrics;
+using Cratis.Traces;
+
+namespace MyApplication.Reports;
+
+public static partial class ReportInstrumentation
+{
+    [Counter<int>("reports.completed", "Completed reports")]
+    internal static partial void Completed(this IMeter<ReportWorker> meter,
+        [Tag("reports.outcome")] string outcome);
+
+    [Gauge<int>("reports.pending", "Pending reports")]
+    internal static partial void Pending(this IMeter<ReportWorker> meter, int count);
+
+    [Histogram<double>("reports.duration", "Report duration", "s")]
+    internal static partial void Duration(this IMeter<ReportWorker> meter, double seconds);
+
+    [Span("reports.build", ActivityKind.Internal)]
+    internal static partial IActivityScope<ReportWorker> Build(
+        this IActivitySource<ReportWorker> source,
+        [Tag("reports.format")] string format);
+}
+```
+
+- The first metric argument is `IMeter<T>` or `IMeterScope<T>`. A counter without a measurement increments by one. The first remaining parameter, in any position, whose type exactly matches the attribute's numeric type is the measurement, not a tag; avoid a second parameter of that type. Gauges and histograms require that measurement (`MetricsSourceGenerator.cs:285-337`).
+- Remaining parameters are tags. Metric keys default to parameter names; span keys default to snake_case. `[Tag("key")]` from `Cratis.Diagnostics` overrides either (`:174-185,403`).
+- `IMeterScope<T>` merges scope tags with method tags (`Templates/Metrics.hbs:34-38,67-71,96-100`). Do not put credentials, personal payloads or unbounded entity IDs in metric labels; choose bounded categories.
+- Name, description and optional UCUM unit are distinct. A duration in seconds uses `"s"` and a measurement in seconds, not milliseconds (`HistogramAttribute.cs:14-29`, template `:109`).
+- A span returns `IActivityScope<T>` and takes `IActivitySource<T>` first. Assign the returned scope with `using`; `CRT0001` checks disposal (`ActivityScopeUsingAnalyzer.cs:20`, `Templates/Metrics.hbs:118-122`).
+
+Call-site excerpt inside the existing worker, with injected `IMeter<ReportWorker> meter` and `IActivitySource<ReportWorker> source`:
+
+```csharp
+using var activity = source.Build("pdf");
+meter.Pending(3);
+meter.Completed("succeeded");
+meter.Duration(0.25);
+```
+
+This shows recording, not report execution. Both `AddBindingsByConvention()` and `AddSelfBindings()` register unkeyed `IMeter<>` and `IActivitySource<>` as singletons. For a plain host, use the normal type-discovery/convention setup from **cratis-fundamentals-type-discovery**; a generated method alone does not register its dependencies.
+
+## 2. Subscribe the actual instrumentation name
+
+**Unkeyed instruments use `typeof(T).FullName`**, not the metric name and not the host service name. `AddCratisInstrumentation()` subscribes only to `Cratis.*`. An application namespace such as `MyApplication.Reports.ReportWorker` needs an explicit meter/source subscription. This is the first check when generation works but nothing is exported.
+
+Reference `Cratis.OpenTelemetry` explicitly for SDK/exporter setup. Host-setup excerpt for an existing `IHostApplicationBuilder builder` (including a `WebApplicationBuilder`), before building the host:
+
+```csharp
+using Cratis.OpenTelemetry;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+using MyApplication.Reports;
+
+builder.AddCratisOpenTelemetry(options =>
+{
+    options.ServiceName = "report-service";
+    options.ConfigureMetrics = metrics => metrics.AddMeter(typeof(ReportWorker).FullName!);
+    options.ConfigureTracing = tracing => tracing.AddSource(typeof(ReportWorker).FullName!);
+});
+```
+
+`AddCratisOpenTelemetry` extends `IHostApplicationBuilder`. When the host already owns an OpenTelemetry builder, use `services.AddOpenTelemetry().WithCratis(configuration, configure)` instead; `WithCratis` extends `OpenTelemetryBuilder`. Do not add both setups. If the application only wants subscription helpers, `AddCratisInstrumentation()` extends both `TracerProviderBuilder` and `MeterProviderBuilder`, not the service collection (`OpenTelemetryExtensions.cs:29-71`, `InstrumentationExtensions.cs:24-31`).
+
+Shared setup adds Cratis sources/meters, ASP.NET Core and HTTP client instrumentation, runtime metrics, and scoped/formatted logs. Application callbacks run before DI is built (`OpenTelemetryExtensions.cs:77-180`).
+
+## 3. Configure export, without baking endpoints or secrets into code
+
+At this tag, OTLP export is **opt-in**: no configured endpoint means no OTLP exporter. Environment values take precedence over configuration keys. Relevant standard keys (`OpenTelemetryExtensions.cs:215-315`):
+
+| Key | Effect |
+| --- | --- |
+| `OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES` | Resource values override application defaults |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | Shared absolute HTTP/HTTPS endpoint |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, `_METRICS_ENDPOINT`, `_LOGS_ENDPOINT` | Signal-specific endpoints override the shared endpoint |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` (or signal-specific equivalent) | `http/protobuf` selects HTTP; otherwise gRPC |
+| `OTEL_TRACES_EXPORTER`, `OTEL_METRICS_EXPORTER`, `OTEL_LOGS_EXPORTER` | If supplied, must include `otlp` for that signal to export |
+| `OTEL_SDK_DISABLED=true` | Disables providers |
+| `OTEL_METRIC_EXPORT_INTERVAL`, `OTEL_METRIC_EXPORT_TIMEOUT` | Metric reader timing in milliseconds |
+| `OTEL_TRACES_SAMPLER`, `OTEL_TRACES_SAMPLER_ARG` | Sampler and ratio configuration |
+
+For HTTP/protobuf, the shared endpoint gains `/v1/traces`, `/v1/metrics` or `/v1/logs`; signal-specific endpoints are used as supplied. An enabled invalid endpoint throws `InvalidOpenTelemetryEndpoint`. Treat exporter headers as secrets; obtain them through the approved environment/secret mechanism, never a snippet or committed configuration.
+
+## Upgrade and prove it
+
+- Fundamentals stopped bringing the OpenTelemetry SDK transitively in **7.20.2**; add the explicit telemetry package when migrating a consumer that relied on that dependency (`Documentation/csharp/opentelemetry.md`).
+- Regeneration after the **7.20.0** unit correction can rename exported Prometheus metrics: descriptions are now HELP text, not units. Rebuild the consumer and update dashboards/alerts that used the old description-suffixed names (`metrics/roslyn.md`, template `:48-50,80,109`).
+- Build with analyzers and warnings as errors. Inspect generated implementations for correct measurements/tags and scope disposal. Do not edit generated files.
+- Exercise one code path with a listener or the configured collector: observe the counter increment, histogram unit/measurement and completed span. A build or `skill-contains` assertion is not proof of export. Check namespace subscriptions, SDK disablement, sampler and endpoint independently before diagnosing the collector.

package/package/corpus/skills/cratis-fundamentals-telemetry/verification.json

@@ -0,0 +1,15 @@
+{
+  "skill": "cratis-fundamentals-telemetry",
+  "input": "Generate service metrics and spans and diagnose why an application's unkeyed meter is not exported.",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "static partial class in a namespace" },
+    { "kind": "skill-contains", "value": "Histogram<double>" },
+    { "kind": "skill-contains", "value": "IActivityScope<ReportWorker>" },
+    { "kind": "skill-contains", "value": "CRT0001" },
+    { "kind": "skill-contains", "value": "typeof(T).FullName" },
+    { "kind": "skill-contains", "value": "AddCratisOpenTelemetry" },
+    { "kind": "skill-contains", "value": "no configured endpoint means no OTLP exporter" },
+    { "kind": "skill-contains", "value": "descriptions are now HELP text, not units" }
+  ]
+}

package/package/corpus/skills/cratis-orleans-jobs/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: cratis-orleans-jobs
+description: Build recoverable work with Cratis.Orleans jobs and job-step grains, stage barriers, bounded startup and cleanup, storage scopes and state machines. Use for service or kernel job authors, job recovery, SQL schema setup, or grain lifecycle transitions. Framework guidance; do not use for operating live Chronicle jobs or for application command validation.
+license: MIT
+---
+
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Recoverable Orleans jobs
+
+For services and kernel contributors using Orleans. This is library-consumer guidance, not the application vertical-slice architecture. For live Chronicle operations use **cratis-chronicle-cli-operations** instead. Co-hosting conventions are in [orleans.md](../../rules/orleans.md).
+
+## Verified product sources
+
+All Orleans claims below are source reads from **Cratis/Orleans v1.16.3**.
+
+| Packages | Version | Sources |
+| --- | --- | --- |
+| `Cratis.Orleans`, `Cratis.Orleans.Storage` | `1.16.3` | `Source/Orleans/Jobs/{Job.cs,Job.Steps.cs,Job.Stages.cs,JobStep.cs,IJobsManager.cs,JobsOptions.cs}`; `Source/Orleans.Storage/Jobs/*` |
+| `Cratis.Orleans.Storage.MongoDB`, `Cratis.Orleans.Storage.Sql` | `1.16.3` | `Source/Orleans.Storage.MongoDB/{MongoDBJobsStorageOptions.cs,DatabaseNames.cs}`; `Source/Orleans.Storage.Sql/{SqlJobsStorage.cs,SqlJobsStorageOptions.cs,Jobs/Migrations/v1_0_0.cs}` |
+| `Cratis.Orleans.Chronicle` | `1.16.3` | `Source/Orleans.Chronicle/StateMachines/EventSourcedStateMachine.cs:19-40,77-94,128-176`; [state-machine reference](references/state-machines.md) |
+
+The API snippets cite their exact files and lines below. Product docs `Documentation/concepts/{jobs,storage-scopes,state-machines,event-sourced-state-machines}.md` supply the task vocabulary; source resolves contradictions.
+
+## 1. Choose a job, not a detached task
+
+A job plans recoverable work; each step is a grain and does the work. Use it for work that must outlive a request. It is **at-least-once**, not exactly-once: a step interrupted before a durable checkpoint can perform the same work again. Protect external effects with receiver-owned idempotency/deduplication; a checkpoint does not atomically commit an external write (`JobStep.cs:47-56`, `JobsOptions.cs:34-59`).
+
+- Job: derive `Job<TRequest, TJobState>`; the request is a class implementing `IJobRequest`, the state derives `JobState` (`Job.cs:23-25`). Implement `PrepareSteps(TRequest)` returning `Task<IImmutableList<JobStepDetails>>` (`Job.Steps.cs:63-87`).
+- Step: derive `JobStep<TRequest, TResult, TState>`; state derives `JobStepState`. Its constructor receives `[PersistentState(nameof(JobStepState), WellKnownGrainStorageProviders.JobSteps)] IPersistentState<TState>`, `IJobStepThrottle`, and `ILogger<JobStep<TRequest, TResult, TState>>` (`JobStep.cs:27-32`).
+- Implement `PrepareStep(TRequest)` → `Task<Result<PrepareJobStepError>>`; `InitializeState(TRequest)` → `ValueTask`, called after preparation succeeds; and `PerformStep(TState, CancellationToken)` → `Task<Catch<JobStepResult>>` (`JobStep.cs:350-387`). `TResult` is the step's result type; the work method returns the framework's `JobStepResult` envelope, not `TResult` directly.
+- Give the concrete job and step unique `[GrainType("product-specific-name")]` names. Use serializable request/state/result types. Do not reuse a class-derived grain name across assemblies (`Jobs/JobsManager.cs:31`, `Documentation/how-to/host-the-silo.md`, and `orleans.md`).
+
+`PerformStep` runs **outside the activation context** with a state snapshot obtained through the grain reference. Mutating that snapshot does not persist it; do not access/write grain `State` directly from background work (`JobStep.cs:375,390-450`). Keep progress/state coordination on grain calls. Since 1.16.2 the framework owns stop reporting; do not report cancellation again from a `PerformWork` override (`:390-450`, `Documentation/concepts/jobs.md:117-120`).
+
+## 2. Plan dependencies as stages
+
+Default steps all use `JobStepStage.First`. Prefer independent fan-out. Use stages only when correctness requires earlier work to finish (`Job.Stages.cs:20-44`).
+
+Planning excerpt inside an existing `Job<RecoveryRequest, RecoveryState>`. It assumes `RecoveryRequest : IJobRequest`, `RecoveryState : JobState`, and the two existing grain interfaces `IRepairIndex` and `IRebuildCatalog`, each deriving a typed `IJobStep<,,>`:
+
+```csharp
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+protected override Task<IImmutableList<JobStepDetails>> PrepareSteps(RecoveryRequest request) =>
+    Task.FromResult<IImmutableList<JobStepDetails>>(
+    [
+        CreateStep<IRepairIndex>(request, stage: 0),
+        CreateStep<IRebuildCatalog>(request, stage: 10)
+    ]);
+```
+
+Import `System.Collections.Immutable` and `Cratis.Orleans.Jobs` in that job file. `CreateStep<TStep>` takes the **grain interface**, not the implementation (`Job.Steps.cs:69-79`). Its stage overload accepts `JobStepStage`, with implicit integer conversion (`Source/Orleans.Storage/Jobs/Stages/JobStepStage.cs`).
+
+Every step in a stage reaches an outcome before later stages start; steps within a stage run in parallel. All steps are prepared up front, so later-stage preparation cannot read the effects of earlier-stage execution. Read such dependencies in `PerformStep` (`Job.Stages.cs:27-33`).
+
+A failed stage stops the pipeline by default: later steps become `Unreachable`, and the job completes with failures. A best-effort stage may override `GetFailureBehaviorFor(JobStepStage)` to return `JobStageFailureBehavior.ContinueWithNextStage` (`Job.Stages.cs:40-44,152-194`, namespace `Cratis.Orleans.Jobs.Stages`). Do not silently continue when a later stage relies on the failed output.
+
+## 3. Start and resume through the scoped manager
+
+`IGrainFactory.GetJobsManager(scope, namespace)` resolves the manager (`JobsManagerExtensions.cs:18-19`). `IJobsManager.Start<TJob,TRequest>(request)` returns `Result<JobId, StartJobError>`; inspect its error before telling a caller that a job started (`IJobsManager.cs:37-52`). Start success is not completed work; observe the job's status/outcomes.
+
+`IJobsManager.Resume(JobId)` returns **`Task<bool>`**. False means nothing took the job; do not wait for a completion callback as though resumption succeeded. True can mean resumed, already running, or finalized as completed (`IJobsManager.cs:54-64`). `Rehydrate()` completes after loading/preparing interrupted jobs, **before** its bounded background drain has resumed them all (`:15-28`).
+
+`StartStepsInBackground` defaults to false. Overriding it to true makes Start return once the job is durable, moving step preparation/start to the grain's next turn. Later startup errors belong to the job, not the Start response (`Job.cs:74-87,395-427`).
+
+## 4. Know what storage retains
+
+Successful jobs clear themselves by default; override `KeepAfterCompleted` to retain job state. Jobs completed with failures default to `KeepAfterCompletedWithFailures = true`, but retention cleanup still applies (`Job.cs:58-71`, `JobsOptions.cs:80-97`).
+
+**Keeping a job does not keep successful step state.** The step provider deletes successful/removing state, moves failed state to failed-step storage, and saves stopped/scheduled/running/unreachable state (`JobStepGrainStorageProvider.cs:64-84`). SQL keeps failed step rows with a failure status rather than a separate collection (`Source/Orleans.Storage.Sql/Jobs/JobStepStorage.cs`, `MoveToFailed`). Copy results the job must retain through `OnStepCompletedOrStopped(JobStepId, JobStepResult)` into job state (`Job.Steps.cs:49-55,110-117`); do not read deleted successful step state later.
+
+Deliver external callbacks to a method on the **job's grain interface**, update job state there and persist it with `WriteState()`. Preserve the returned `Catch` failure; do not acknowledge input whose write failed (`Job.State.cs:13-25`, `WriteState`; `Documentation/concepts/jobs.md:122-164`). Step state is not a callback inbox: a concurrent callback can race the final write, and successful completion deletes it. A running step's snapshot will not see later job/step writes automatically.
+
+## 5. Register storage and budget concurrency
+
+`IJobsStorage.GetFor(scope, namespace)` returns `JobsStorage`. Scope and namespace are opaque engine coordinates carried in grain keys; the host/provider owns their mapping (`Source/Orleans.Storage/Jobs/IJobsStorage.cs`, `Job.cs:120-125`). They are storage boundaries, not authorization checks.
+
+Choose one storage registration alongside `AddCratisOrleans`:
+
+| Registration | Package / namespace | Use |
+| --- | --- | --- |
+| `AddCratisOrleansMongoDBJobsStorage` | `.Storage.MongoDB` / `Cratis.Orleans.Setup` | Durable MongoDB; database-name resolver can override the default `{scope}+jobs[+{namespace}]` |
+| `AddCratisOrleansSqlJobsStorage` | `.Storage.Sql` / `Cratis.Orleans.Setup` | Durable EF Core; `OptionsResolver(scope, namespace)` selects typed `DbContextOptions<JobsDbContext>` |
+| `AddCratisOrleansInMemoryJobsStorage` | `.Storage` / `Cratis.Orleans.Storage` | Specs/development only; process restart loses state |
+
+Evidence: each package's `*JobsStorageServiceCollectionExtensions.cs`; MongoDB `DatabaseNames.cs` and `MongoDBJobsStorageOptions.cs`; SQL `SqlJobsStorageOptions.cs:15-27`; in-memory `InMemory/InMemoryJobsStorage.cs`.
+
+### SQL schema contradiction resolved
+
+The product's SQL setup docs say to create the schema yourself. **At v1.16.3 the provider applies migrations automatically**: `SqlJobsStorage.GetFor` calls `EnsureSchema`, which calls `dbContext.Database.Migrate()` before constructing storage (`Source/Orleans.Storage.Sql/SqlJobsStorage.cs:33-49,58-74`). The migration is `Jobs/Migrations/v1_0_0.cs`; do not substitute `EnsureCreated` or hand-create those tables. The connection needs permissions to apply the migration, and scope-to-database mapping must be deliberate. Storage is cached per scope/namespace; `IJobsStorage.Reset()` clears the cache and the next resolution migrates again (`SqlJobsStorage.cs:52-56`). This resolves the documentation conflict from source, not from a release-note inference.
+
+Configure `JobsOptions` through the host's options registration. Its properties are **init-only**: supply a constructed instance via the options mechanism rather than assigning them in a `Configure(options => options.Property = …)` callback (`JobsOptions.cs`).
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `MaxParallelSteps` | `max(1, ProcessorCount - 1)` when unset | Actual execution throttle |
+| `MaxConcurrentStepStarts` | `16` | Startup/resume calls per job, not the execution limit |
+| `MaxConcurrentRehydration` | `8` | Jobs resumed concurrently by a manager |
+| `MaxConcurrentCleanup` | `4` | Dead-job deletions |
+| `StepCheckpointBatchInterval` | `100` | Batches between durable progress checkpoints |
+| `StepCheckpointFlushInterval` | `5 seconds` | Timed checkpoint flush; nonpositive disables it |
+| `DeadJobThreshold`, `CleanupCadence` | `1 hour` each | Preparation-with-no-steps scavenging |
+| `TerminalJobRetention` | `7 days` | Terminal history retention; `Timeout.InfiniteTimeSpan` retains indefinitely |
+| `MaxTerminalJobsPerCleanup` | `100` | Bounded oldest-first cleanup page |
+
+Source: `JobsOptions.cs:17-109`. The three concurrency options for starts/rehydration/cleanup treat values below one as one. Retention does not delete preparing/running/stopped/removing jobs. Larger checkpoint intervals mean more post-crash redelivery, not higher delivery guarantees.
+
+## State machines and verification
+
+Use [state-machines.md](references/state-machines.md) for `StateMachine<TStoredState>` and `EventSourcedStateMachine<TModel>`: jobs are recoverable work, state machines are lifecycle behavior. Neither makes external effects exactly-once.
+
+Verify a new job with specs for planning, idempotent redelivery, stop/resume (including false), failed barriers/Unreachable, retention and persistence failures. Exercise the selected durable provider for restart recovery and SQL migration permissions. A build alone cannot establish crash recovery. Do not operate a live store merely to validate a code example.

package/package/corpus/skills/cratis-orleans-jobs/references/state-machines.md

@@ -0,0 +1,64 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Grain lifecycle state machines
+
+Verified from **Cratis/Orleans v1.16.3**. Use explicit states when entering/leaving a status has behavior; an enum is enough for a status with no behavior. Do not put long-running work on a grain turn just because `OnEnter` is available.
+
+## Stored lifecycle
+
+`StateMachine<TStoredState>` derives from a stateful grain. Override `InitialState` and `CreateStates()`; states derive `State<TStoredState>`. `AllowedTransitions` is an immutable list of target types, or override `CanTransitionTo<TTargetState>(storedState)` for a guard (`Source/Orleans/StateMachines/StateMachine.cs:63-67,120-192`; `State.cs:17-34`).
+
+Declaration excerpt for an existing grain file with `ProcessState : StateMachineState`, the existing `IProcess` grain interface, and a registered `processes` grain storage provider:
+
+```csharp
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Cratis.Orleans.StateMachines;
+using Orleans;
+using Orleans.Providers;
+
+[GrainType("my-product-process")]
+[StorageProvider(ProviderName = "processes")]
+public class Process : StateMachine<ProcessState>, IProcess
+{
+    protected override Type InitialState => typeof(Pending);
+
+    public override IImmutableList<IState<ProcessState>> CreateStates() =>
+        [new Pending(), new Finished()];
+
+    public Task Finish() => TransitionTo<Finished>();
+}
+
+public class Pending : State<ProcessState>
+{
+    protected override IImmutableList<Type> AllowedTransitions => [typeof(Finished)];
+}
+
+public class Finished : State<ProcessState>;
+```
+
+Split types into their house-style files in the consumer; the block collects declarations to show the API. Do not copy the `processes` provider name into Chronicle's kernel; use its registered constants.
+
+A refused transition is a **no-op**, not an exception or a successful change. An unknown target throws `UnknownStateTypeInStateMachine`. The machine runs leaving hooks, `OnLeave`, entering hooks, `OnEnter`, then persistence (`StateMachine.cs:162-169,222-290`). Transitions requested while entering are scheduled; transitions while leaving throw `TransitioningDuringOnLeaveIsNotSupported`.
+
+When stored state derives `StateMachineState`, `CurrentState` stores the state's full type name; activation resolves it, enters it again, and can repeat enter effects. Renames need a stored-value migration; an unknown recorded name throws `UnknownCurrentState` (`StateMachine.cs:183-191,261-264`). A self-transition with the **same state instance** skips persistence: return a new stored-state instance when a self-transition must write (`:266-272`).
+
+For externally owned storage, the protected constructor accepts `Orleans.Core.IStorage<TStoredState>` and reads it on activation before the activation hook. Override `ResolveActivationState()` to derive lifecycle from authoritative state instead of persisting a second status (`:39-51,68-95,172-192`).
+
+## Lifecycle following Chronicle facts
+
+`EventSourcedStateMachine<TModel>` from `Cratis.Orleans.Chronicle.StateMachines` uses a Chronicle read model as authoritative state. Its interface derives `IEventSourcedStateMachine` (string-keyed). There is **no grain storage provider** to configure and writes are no-ops: `ReadModelStorage<TModel>` reads Chronicle; `ResolveState(TModel?)` derives activation state (`Source/Orleans.Chronicle/StateMachines/EventSourcedStateMachine.cs:19-40,77-94,155-176`; `ReadModelStorage.cs:68-95`).
+
+- Define states with `CreateStates()` as above, over `TModel`.
+- Define event transitions in `DefineTransitions(IStateMachineTransitions<TModel>)`, using `.On<TEvent>().When(model => predicate).TransitionTo<TState>()`. First applicable allowed transition wins. Make `ResolveState` agree with these transitions after restart (`EventSourcedStateMachine.cs:142-176`, `StateMachineTransitions.cs`).
+- Use model-bound projection attributes, an already-discovered projection, or `DefineProjection(IProjectionBuilderFor<TModel>)`, not competing projections. `DefineProjection` and `DefineTransitions` run at startup **without a constructor**: use only the builder, never injected services or fields (`EventSourcedStateMachine.cs:34-37`).
+- Register `AddEventSourcedStateMachines()` on `ISiloBuilder` or `IServiceCollection`, beside the application's Chronicle client registration; namespace `Cratis.Orleans.Chronicle.Hosting` (`Hosting/EventSourcedStateMachinesServiceCollectionExtensions.cs:30-55`).
+- Grain keys include event store, namespace and event-source ID. Use `IGrainFactory.GetEventSourcedStateMachine<TInterface>(eventStore, eventSourceId)` from `Cratis.Orleans.Chronicle.StateMachines` so tenant coordinates come from the supplied event store (`StateMachines/EventSourcedStateMachineGrainFactoryExtensions.cs:21-52`).
+- Prefer passive models. For events consumed by a materialized projection, the reactor waits for its sequence position before refreshing; `ModelCatchUpTimeout` defaults to 30 seconds and expiry fails with `ModelDidNotCatchUp` (`EventSourcedStateMachineReactor.cs:58-89`; `EventSourcedStateMachinesOptions.cs:26`).
+
+This machine **follows facts**, it does not arbitrate whether a command may append one. Keep command rejection and append-time invariants at their owning boundary. Enter/model-change effects may repeat on activation, redelivery or replay: design them idempotently (`Documentation/concepts/event-sourced-state-machines.md:240-247`). Test guards, no-op refusals, reactivation and persistence failures separately from job recovery.

package/package/corpus/skills/cratis-orleans-jobs/verification.json

@@ -0,0 +1,20 @@
+{
+  "skill": "cratis-orleans-jobs",
+  "input": "Author a staged recoverable job with SQL storage and distinguish lifecycle state machines from job execution.",
+  "fixtures": [],
+  "assertions": [
+    { "kind": "skill-contains", "value": "at-least-once" },
+    { "kind": "skill-contains", "value": "Task<Catch<JobStepResult>>" },
+    { "kind": "skill-contains", "value": "CreateStep<IRepairIndex>(request, stage: 0)" },
+    { "kind": "skill-contains", "value": "Unreachable" },
+    { "kind": "skill-contains", "value": "Task<bool>" },
+    { "kind": "skill-contains", "value": "Keeping a job does not keep successful step state" },
+    { "kind": "skill-contains", "value": "dbContext.Database.Migrate()" },
+    { "kind": "skill-contains", "value": "MaxConcurrentStepStarts" },
+    { "kind": "skill-contains", "value": "StateMachine<TStoredState>" },
+    { "kind": "skill-contains", "value": "EventSourcedStateMachine<TModel>" },
+    { "kind": "skill-contains", "file": "references/state-machines.md", "value": "A refused transition is a **no-op**" },
+    { "kind": "skill-contains", "file": "references/state-machines.md", "value": "without a constructor" },
+    { "kind": "skill-contains", "file": "references/state-machines.md", "value": "same state instance" }
+  ]
+}

package/package/corpus/skills/cratis-screenplay-model-authoring/references/screen-authoring-workflow.md

@@ -168,10 +168,12 @@ Historical verified public vector and executable checks:
 - render (`cratis render <corpus-folder> --name ScreenComposition --destination
   <dir> -o json`) with CLI 3.43.0 publishes the corpus; the browser acceptance
   run on CLI 3.40.7 passed 51 assertions (Cratis/Screenplay#605);
-- still refused by design: guarded Close (`STAGE-SCENE-ACTION-001`) and
-  double-click (`STAGE-SCENE-INTERACTION-001`); still pending: Studio production
-  Play proof (test-account decision). UI-profile rejection and render-then-recover
-  shipped in Cratis/cli#301.
+- guarded Close and double-click: refused with `STAGE-SCENE-ACTION-001` and
+  `STAGE-SCENE-INTERACTION-001` on this historical vector, rendered and run since
+  Stage 4.65 (live browser run on CLI 3.53.1 with `cratis/stage:4.73.1`,
+  Cratis/Screenplay#671); the codes remain for a guard Stage cannot evaluate. Studio
+  production Play proof is a separate vector (Cratis/Screenplay#173). UI-profile
+  rejection and render-then-recover shipped in Cratis/cli#301.
 
 ## Replay the workflow in CI without a Screenplay checkout
 

package/package/corpus/skills/cratis-screenplay-read-surface/references/guarded-actions.md

@@ -77,7 +77,9 @@ second command. Screens remain outside portable ESM execution. A downstream
 renderer must explicitly admit guarded selection or report unsupported behavior,
 not approximate it as a plain action. Checked at historical CLI 3.41.0: its bundled
 screen renderer reported unsupported guarded actions with STAGE-SCENE-ACTION-001; source compilation alone
-cannot establish usable controls.
+cannot establish usable controls. Since Stage 4.65 a guard comparing `item.<field>` with a literal is
+rendered and evaluated at runtime (public CLI 3.53.1 with `cratis/stage:4.73.1`, Cratis/Screenplay#671);
+STAGE-SCENE-ACTION-001 remains for a guard Stage cannot evaluate.
 
 Authority: Screenplay `v4.125.0:Documentation/screenplay/screens.md`;
 CLI `v3.41.0:Documentation/reference/screenplay.md` for renderer disposition.

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

@@ -35,8 +35,9 @@ Runs: the worked example (`references/worked-example.md`) was probed with cratis
 corpus was rendered and published successfully, and an MCP-edited copy was rendered, run and checked in
 the browser; the CLI 3.40.7 browser acceptance run passed 51 assertions (Cratis/Screenplay#605). The AI
 repository's `screenplay-mcp-transcript.ts` harness proves the real stdio proposal/apply path against the
-packaged CLI. Guarded Close actions (`STAGE-SCENE-ACTION-001`) and double-click interactions
-(`STAGE-SCENE-INTERACTION-001`) are refused and recorded as unsupported, never emulated. UI-profile
+packaged CLI. Guarded Close actions and double-click interactions were refused (`STAGE-SCENE-ACTION-001`,
+`STAGE-SCENE-INTERACTION-001`) on that vector; since Stage 4.65 they render and run, and the codes
+remain for a guard Stage cannot evaluate, which is never emulated (Cratis/Screenplay#671). UI-profile
 rejection (`CLI-RENDER-007` to `-010`) and render-then-recover shipped in 3.41.0 (Cratis/cli#301). The
 renderer facts are owned by `cratis-stage-rendering-and-sandbox`; this skill links them and never
 restates the admission table.

package/package/corpus/skills/cratis-screenplay-ui-composition/references/screen-composition-contract.md

@@ -54,10 +54,11 @@ All three levels hold for the canonical `ScreenComposition` corpus on the histor
   comments, deep links, stale-response handling and theme included. On CLI
   3.43.0 an agent-edited column was rendered, run and seen in the browser.
 
-Still true: a guarded Close action and a double-click interaction are refused
-(`STAGE-SCENE-ACTION-001`, `STAGE-SCENE-INTERACTION-001`, defined from Stage
-4.51 through 4.57) and recorded as unsupported, never emulated; Studio production
-Play proof is pending a test-account decision. Refusing an unresolvable UI
+Guarded Close and double-click: Stage refused both with `STAGE-SCENE-ACTION-001` and
+`STAGE-SCENE-INTERACTION-001` from Stage 4.51 through 4.57. Since Stage 4.65 they render and
+run (public CLI 3.53.1 with `cratis/stage:4.73.1`, Cratis/Screenplay#671); the codes remain the
+refusal for a guard Stage cannot evaluate, which is never emulated. Studio production Play
+proof is a separate vector (Cratis/Screenplay#173). Refusing an unresolvable UI
 profile and recovering a rendered application shipped in Cratis/cli#301. (History: on Stage 4.24.2 or
 cratis 3.28.x renderers authored screens were reported as omitted/default composition; Stage 4.73.1
 (CLI 3.53.1) renders navigation contributions and toolbars, and `CLI-RENDER-015`, which refused them, is retired.)
@@ -124,7 +125,8 @@ from parsing; do not publish an empty plain action as equivalent behavior.
 The complete checked model and conditions are in
 `cratis-screenplay-read-surface` `references/guarded-actions.md`, grounded in
 Screenplay v4.125.0 `screens.md`. Historical CLI 3.41.0/Stage 4.51.3 checks reported
-unsupported screen actions with STAGE-SCENE-ACTION-001, not proof of runtime selection.
+unsupported screen actions with STAGE-SCENE-ACTION-001; since Stage 4.65 a guard of the form
+`item.<field>` compared with a literal is evaluated at runtime (Cratis/Screenplay#671).
 
 ## Exposed template configuration
 

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

@@ -24,10 +24,10 @@ browser assertions passed, none blocked or pending (Cratis/Screenplay#605).
 Native command forms, required fields, scoped comments, deep links,
 stale-response handling and theme all pass there. On public CLI 3.43.0 (default
 `cratis/stage:4.52.0`) an agent-edited table column was rendered, run and seen in
-the browser. Two behaviors stay fail-closed by design: a guarded Close action
-(`STAGE-SCENE-ACTION-001`) and a double-click interaction
-(`STAGE-SCENE-INTERACTION-001`) are refused and recorded as unsupported
-capabilities, never emulated. Require a generated plan or artifact entry for every
+the browser. Guarded Close and guarded double-click run since
+Stage 4.65: on CLI 3.53.1 with `cratis/stage:4.73.1` Close shows only while the item is
+open and a double click navigates or notifies by row (Cratis/Screenplay#671). `STAGE-SCENE-ACTION-001` and `STAGE-SCENE-INTERACTION-001` still
+refuse a guard Stage cannot evaluate: no artifacts. Require a generated plan or artifact entry for every
 authored UI construct, and report every unsupported UI directive as a diagnostic.
 Silent fallback to a default screen is a failure, not a partial render.
 

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

@@ -3,6 +3,7 @@
 ## Contents
 
 - Current behavior at Stage 4.73.1 (source reading; Docker not run)
+- Specification engine selection at Stage 4.78.0 and CLI 3.53.1
 - The sandbox: a partial, disposable runtime
 - The specification runner
 - Choosing between them
@@ -25,6 +26,31 @@ it prints a deprecation notice, refuses routes with exit 1 and writes no results
 `0`/`1`/`2` are as in `SKILL.md`. The sections below describe the 4.24-era behavior and remain the
 engine comparison.
 
+## Specification engine selection at Stage 4.78.0 and CLI 3.53.1
+
+Re-verified from Stage `v4.78.0`, `Source/SpecRunner/SpecRunnerArguments.cs:18,76`,
+`Program.cs:46–78,86–113`, and
+`Source/Specifications/SemanticSpecificationExecutor.cs:115–136,183–197`:
+
+- The runner still defaults to deprecated `structural`, which executes no slice.
+  Pass `--engine semantic` to the **Stage specification runner**, not to `cratis run`.
+- Semantic execution creates a fresh Chronicle in-memory event log per
+  specification and dispatches admitted commands through Arc's in-memory
+  pipeline. The `stage-spec-run/1` report carries `Passed`, `Failed`, `Unsupported`
+  or `Cancelled`; exit `0` only proves the report was written, not that specs passed
+  (`Documentation/docker/spec-runner.md:150–174`).
+- CLI `v3.53.1` does **not** expose `--engine` or a Stage specification-runner
+  command. Its `run` command starts the **sandbox**, with path, tag, port,
+  workbench-port and verbose settings only (`Source/Cli/Commands/Run/RunSettings.cs:9–52`,
+  `RunCommand.cs:10–23,100–105`). Changing `--tag` does not select an engine.
+  For semantic specifications use the runner directly, for example
+  `cratis/stage-specrunner:4.78.0 --engine semantic`; for the sandbox, engine
+  selection is the separate `Stage__Runtime__Engine=semantic` environment setting.
+
+This is source verification, not an executed Docker run. It updates engine
+selection only; the historical capability lists below are not a complete
+admission inventory for Stage `v4.78.0`.
+
 ## The sandbox: a partial, disposable runtime
 
 `cratis/stage` is the Stage host plus an in-memory Chronicle kernel. Each session starts

package/package/corpus/skills/cratis-stage-rendering-and-sandbox/verification.json

@@ -23,6 +23,9 @@
     { "kind": "skill-contains", "value": "`Customizations/`" },
     { "kind": "skill-contains", "value": "`Stage__Runtime__Engine=semantic`" },
     { "kind": "skill-contains", "value": "`--engine semantic`" },
+    { "kind": "skill-contains", "value": "Stage `v4.78.0`", "file": "references/sandbox-and-specrunner.md" },
+    { "kind": "skill-contains", "value": "does **not** expose `--engine`", "file": "references/sandbox-and-specrunner.md" },
+    { "kind": "skill-contains", "value": "fresh Chronicle in-memory event log per", "file": "references/sandbox-and-specrunner.md" },
     { "kind": "skill-contains", "value": "through v10" },
     { "kind": "skill-contains", "value": "CLI-RENDER-004" },
     { "kind": "skill-contains", "value": "STAGE-ESM-024" },

package/package/profile-catalog.json

@@ -631,6 +631,8 @@
       "id": "cratis/components",
       "availableTargets": [
         "cratis-components-accessibility",
+        "cratis-components-common-controls",
+        "cratis-components-data-surfaces",
         "cratis-components-schema-editor",
         "cratis-components-stepper-command-dialog",
         "cratis-components-styling",
@@ -760,7 +762,8 @@
     {
       "id": "cratis/fundamentals",
       "availableTargets": [
-        "cratis-fundamentals-concept"
+        "cratis-fundamentals-concept",
+        "cratis-fundamentals-telemetry"
       ],
       "languages": [
         "csharp"
@@ -993,7 +996,8 @@
         "cratis/engineering/core"
       ],
       "availableTargets": [
-        "cratis-engineering-csharp-conventions"
+        "cratis-engineering-csharp-conventions",
+        "cratis-orleans-jobs"
       ],
       "languages": [
         "csharp"

package/package.json

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