@eventmodelers/cli 1.0.73 → 1.0.75

package/stacks/cratis-csharp/templates/.claude/skills/build-state-view/references/patterns.md

@@ -1,166 +0,0 @@
-# Read Slice Patterns — Cratis Arc + Chronicle
-
-Complete code for state-view (read) slices. All artifacts go in a single
-`<Module>/<Feature>/<Slice>/<Slice>.cs` (the shipped starter uses `SomeModule/SomeFeature/...` — match
-whatever the existing slices use). The example slices use no file header (match the project); namespace
-mirrors the folders and drops any `.Features.`. Examples below use short illustrative names
-(`MyApp.Authors.Listing`); mirror your project's actual module/feature layout instead.
-
----
-
-## 1. Read model + queries (snapshot + observable)
-
-```csharp
-// Features/Authors/Listing/Listing.cs
-namespace MyApp.Authors.Listing;
-
-using System.Reactive.Subjects;
-using Cratis.Arc.Queries.ModelBound;
-using MongoDB.Driver;
-
-[ReadModel]
-public record AuthorListItem(AuthorId Id, AuthorName Name, int BookCount)
-{
-    public static async Task<IEnumerable<AuthorListItem>> AllAuthors(
-        IMongoCollection<AuthorListItem> collection)
-        => await collection.Find(Builders<AuthorListItem>.Filter.Empty).ToListAsync();
-
-    public static async Task<AuthorListItem?> GetAuthor(
-        AuthorId id, IMongoCollection<AuthorListItem> collection)
-        => await collection.Find(a => a.Id == id).FirstOrDefaultAsync();
-
-    public static ISubject<IEnumerable<AuthorListItem>> ObserveAllAuthors(
-        IMongoCollection<AuthorListItem> collection)
-        => collection.Observe();
-
-    public static ISubject<AuthorListItem> ObserveAuthor(
-        AuthorId id, IMongoCollection<AuthorListItem> collection)
-        => collection.Observe(a => a.Id == id);
-}
-```
-
-Rules: `[ReadModel]` required; methods `public static`; observable methods return `ISubject<T>`
-directly (never `Task<ISubject<T>>`); `ConceptAs<T>` for identity fields; one read model per use case.
-
----
-
-## 2A. Projection (declarative mapping)
-
-```csharp
-public class AuthorListItemProjection : IProjectionFor<AuthorListItem>
-{
-    public void Define(IProjectionBuilderFor<AuthorListItem> builder) => builder
-        .From<AuthorRegistered>(from => from
-            .Set(m => m.Name).To(e => e.Name)
-            .Set(m => m.BookCount).WithValue(0))
-        .From<BookAdded>(from => from
-            .Add(m => m.BookCount).With(_ => 1))
-        .From<BookRemoved>(from => from
-            .Subtract(m => m.BookCount).With(_ => 1));
-}
-```
-
-- Keyed by **event source id** by default (the id passed to `IEventLog.Append`).
-- AutoMap is on — `.From<E>()` directly; matching property names map automatically.
-- Builder verbs: `Set(...).To(...)` / `.WithValue(...)`, `Add(...).With(...)`, `Subtract(...).With(...)`,
-  `.Join<T>()`, `.Children(...)`. Projections **join events, never read models**.
-
-### Model-bound shorthand (simple cases)
-```csharp
-[ReadModel]
-public record AuthorInfo(
-    [Key] Guid Id,
-    [FromEvent<AuthorRegistered>] string Name,
-    [SetFrom<AuthorRegistered>(nameof(AuthorRegistered.Country))] string Country);
-```
-
----
-
-## 2B. Reducer (running aggregate)
-
-```csharp
-public class AccountBalanceReducer : IReducerFor<AccountBalance>
-{
-    public AccountBalance Opened(DebitAccountOpened @event, AccountBalance? current, EventContext context)
-        => new(0m, context.Occurred);
-
-    public AccountBalance Deposited(FundsDeposited @event, AccountBalance? current, EventContext context)
-        => (current ?? new(0m, context.Occurred)) with { Balance = (current?.Balance ?? 0m) + @event.Amount };
-
-    public AccountBalance Withdrawn(FundsWithdrawn @event, AccountBalance? current, EventContext context)
-        => (current ?? new(0m, context.Occurred)) with { Balance = (current?.Balance ?? 0m) - @event.Amount };
-}
-
-public record AccountBalance(decimal Balance, DateTimeOffset LastUpdated);
-```
-
-Return the complete new state; never mutate `current` (`null` on the first event). Add
-`[FilterEventsByTag]` / `[EventSourceType]` / `[EventStreamType]` when filtering by metadata.
-
----
-
-## 3. Spec — projection result from a sequence of events
-
-```csharp
-namespace MyApp.Authors.Listing.for_AuthorListItem.when_an_author_registered_and_added_two_books;
-
-// Use the project's projection-spec harness (e.g. a ProjectionSpecificationContext / Given<context>).
-// The shape: append events, observe the resulting read model, assert fields.
-
-public class and_projecting : Specification
-{
-    AuthorListItem _result;
-
-    void Establish() { /* append AuthorRegistered, BookAdded, BookAdded to the test event store */ }
-    void Because()   { /* run the projection / read the resulting model */ }
-
-    [Fact] void should_have_the_name()      => _result.Name.Value.ShouldEqual("John");
-    [Fact] void should_count_two_books()     => _result.BookCount.ShouldEqual(2);
-}
-```
-
-Match the project's existing projection-spec harness — discover it from an existing read slice's specs.
-
----
-
-## 4. React — render the query proxy
-
-The query proxy (`AllAuthors.ts`) is generated **next to** `Listing.cs` — import it from the same
-folder. The simplest list UI uses the Cratis `DataTableForObservableQuery` component (see the shipped
-example slice's `ListingDataTable.tsx`):
-
-```tsx
-// Authors/Listing/ListingDataTable.tsx
-import { DataTableForObservableQuery } from '@cratis/components/DataTables';
-import { Column } from 'primereact/column';
-import { AllAuthors } from './AllAuthors';   // co-located generated proxy
-
-export const ListingDataTable = () => (
-    <DataTableForObservableQuery query={AllAuthors} dataKey='id' emptyMessage='No authors yet.'>
-        <Column field='name' header='Name' />
-        <Column field='bookCount' header='Books' />
-    </DataTableForObservableQuery>
-);
-```
-
-Hook form (manual rendering):
-
-```tsx
-const [authors] = AllAuthors.use();              // snapshot or observable, depending on the proxy
-const [result, , setPage] = AllAuthors.useWithPaging(10);   // paging
-// result.data, result.paging.totalItems, result.paging.page
-```
-
-Observable queries generate an `ObservableQueryFor` proxy (from `collection.Observe()`); snapshot
-queries generate `QueryFor`. PrimeReact CSS variables / Tailwind for styling; no `any`; full
-descriptive names. Add a barrel `index.ts` for the slice.
-
----
-
-## Checklist
-
-- One `.cs` file, namespace without `.Features.` (no file header unless the project uses one).
-- `[ReadModel]` record; `public static` query methods; observable returns `ISubject<T>` directly.
-- Projection (mapping) or reducer (aggregate) — discovered automatically, no registration.
-- Projections map from events only; one read model per use case.
-- `ConceptAs<T>` for identity fields; one spec per scenario; `dotnet build` clean; specs pass.

package/stacks/cratis-csharp/templates/build-kit/CLAUDE.md

@@ -1,78 +0,0 @@
-# CratisApp — agent conventions
-
-This is a **Cratis** application: Cratis Arc (CQRS) + Cratis Chronicle (event sourcing) + MongoDB read
-models on the backend, React + TypeScript (Vite + PrimeReact) on the frontend, with **full-stack type
-safety** via TypeScript proxy generation on `dotnet build`.
-
-Build slices with the kit's skills — `/build-state-change`, `/build-state-view`, `/build-automation` —
-and follow the conventions distilled in
-`.build-kit/.claude/skills/_shared/cratis-conventions.md`. **The shipped example slice
-under `SomeModule/SomeFeature/` is the concrete pattern to copy** — match its structure exactly.
-
-**If a slice's requirements are genuinely ambiguous, contradictory, or missing a decision you need in
-order to proceed — do not guess, and do not build anyway.** Invoke the `request-feedback` skill with
-the specific question; it posts the question as a comment on the slice and marks it `Blocked`, and you
-then stop work on this slice for this run. This is an escalation path, not a routine step — read
-`slice.json` and the matching build skill's own instructions fully first; most slices are fully
-specified and need none of this.
-
-## No such thing as harmless drift
-
-`slice.json` is always the desired state — the code follows what it defines, never the other way
-around. If code for a slice already exists — most often because it was previously `Done` and got moved
-back to `Planned` — never conclude "already implemented" and move on. A slice does not return to
-`Planned` without a reason: diff the current `slice.json` against the existing implementation field by
-field (events, commands, params, specifications, routes) and update the code to match every difference
-you find. Only mark it `Done` once there is no gap left.
-
-## Structure (learn from `SomeModule/SomeFeature/`)
-
-```
-<Module>/<Feature>/
-├── <Feature>.tsx            ← composition page (buttons, dialogs, tables)
-├── index.ts                 ← barrel: export * from './<Feature>'
-├── <Concept>.cs             ← shared concepts (ConceptAs<T>)
-└── <Slice>/                 ← one slice = one behavior
-    ├── <Slice>.cs           ← ALL backend artifacts for the slice in ONE file
-    ├── <Proxy>.ts           ← GENERATED by dotnet build — never hand-edit
-    ├── <Component>.tsx      ← React component using the generated proxy
-    └── index.ts             ← barrel export
-```
-
-- Top folder is a **module**, then a **feature**, then **slices**. Namespace is
-  `CratisApp.<Module>.<Feature>.<Slice>` (the `RootNamespace` is `CratisApp` — see `CratisApp.csproj`).
-- **Proxies are generated next to the source** (`CratisProxiesUseSourceFileAsOutputFile=true` in the
-  `.csproj`): `Register.ts` sits beside `Registration.cs`. Frontend imports the proxy from the **same
-  folder** (`import { Register } from './Register'`). Files marked `// @generated` are never edited.
-
-## Non-negotiables (full detail in the shared conventions doc)
-
-- ALL backend artifacts for a slice live in ONE `.cs` file.
-- `[Command]` records define `Handle()` directly — never separate handler classes.
-- `[EventType]` takes NO arguments; events are past-tense and never nullable.
-- `ConceptAs<T>` for identity/value types — no raw `Guid` / `string` in the domain.
-- `[ReadModel]` records expose queries as `public static` methods; observable queries return
-  `ISubject<T>` directly (`collection.Observe()`).
-- Reactors implement the marker `IReactor`; dispatch is by the first parameter type. Write new events
-  only via `ICommandPipeline.Execute(...)`, never `IEventLog`. Keep reactors idempotent + stateless.
-- Frontend: `CommandDialog` / `InputTextField` from `@cratis/components/*`; never import `Dialog` from
-  `primereact/dialog`. PrimeReact CSS variables / Tailwind classes for styling; no `any`.
-
-## Build, run, test
-
-```bash
-docker-compose up -d        # Chronicle (+ MongoDB) + Aspire dashboard
-dotnet build                # compiles backend AND regenerates TypeScript proxies
-dotnet test                 # run specs (filter while iterating: --filter "FullyQualifiedName~<Slice>")
-npm install && npm run dev  # frontend dev server (Vite)
-dotnet run                  # backend (http://localhost:5000, Swagger at /swagger)
-```
-
-**Sequencing is strict:** a slice's frontend cannot reference its proxy until the backend compiles, so
-always go Backend → `dotnet build` → Specs → Frontend → Composition page → Routes (`App.tsx`). Backend
-and frontend of the same slice never run in parallel. Build must be zero-warning, zero-error.
-
-## Learn more
-
-- Cratis docs: https://www.cratis.io/docs/
-- Conventions: `.build-kit/.claude/skills/_shared/cratis-conventions.md`

package/stacks/cratis-csharp/templates/build-kit/lib/AGENT.md

@@ -1,59 +0,0 @@
-# Agent Learnings
-
-Patterns and gotchas discovered during task processing. Update this file whenever you encounter something reusable.
-
-## Cratis non-negotiables (seed — full detail in `.claude/skills/_shared/cratis-conventions.md`)
-
-- ALL backend artifacts for a slice go in ONE `.cs` file under the project's slice folder (the shipped starter uses `<Module>/<Feature>/<Slice>/<Slice>.cs` — discover the real top-level folder from an existing slice). Never split into `Commands/`, `Handlers/`, `Events/`.
-- `[Command]` records define `Handle()` directly on the record — never a separate handler class.
-- `[EventType]` takes NO attribute arguments (the type name is the id); events are past-tense and never nullable.
-- Use `ConceptAs<T>` for every identity/value — no raw `Guid`/`string` in the domain.
-- Read models: `[ReadModel]` record with `public static` query methods on it; observable queries return `ISubject<T>` directly (never `Task<ISubject<T>>`). Projections join events, never read models.
-- Reactors implement the marker `IReactor`; dispatch is by the first parameter type. Write new events only via `ICommandPipeline.Execute(...)`, never `IEventLog`. Reactors must be idempotent and stateless.
-- Namespace mirrors the folders and drops any `.Features.` segment: `<Root>.<Module>.<Feature>.<Slice>` (the starter's `<Root>` is `CratisApp`). Find `<Root>` from the `.csproj` `<RootNamespace>` / existing slices; never hard-code.
-- `dotnet build` generates the TypeScript proxies — backend must compile before a slice's frontend can reference them. Order: Backend → build → Specs → Frontend → Composition.
-- Quality gate: `dotnet build` with zero warnings/errors (warnings = errors); `dotnet test --filter "FullyQualifiedName~<SliceName>"`. File header only if the project's existing `.cs` files already carry one (the shipped example uses none).
-
-## tasks.json
-
-- Tasks are objects with `id`, `createdAt`, and `payload` (a `SliceChangedPayload`).
-- After completing a task, remove it from the array entirely — do not add a status field.
-- Write `[]` to `tasks.json` if the last task is completed.
-
-## SliceChangedPayload fields
-
-```
-event           always "slice:changed"
-organizationId  org UUID or null
-boardId         board UUID
-sliceId         SLICE_BORDER node UUID — use this with /load-slice
-sliceTitle      human-readable slice name (may be null)
-sliceStatus     e.g. "Created", "InProgress", "Done", "Blocked" (may be null)
-timestamp       unix ms when the change was emitted
-```
-
-## Slice files
-
-The realtime agent writes one file per slice on startup and after each `slice:changed` event:
-
-```
-.slices/<context>/<sliceName>/slice.json
-```
-
-- `<context>` is the slice's context value, or `default` if none.
-- `<sliceName>` is the slice title lowercased with spaces removed (e.g. `"Enable User"` → `enableuser`).
-
-These files are always up to date — read them directly before invoking any skill.
-
-## Skill Usage
-
-- Always run `/connect` first to load credentials from `.eventmodelers/config.json` before calling any other skill.
-- `/load-slice sliceId=<uuid>` re-fetches all slices from the API, refreshes the slice files, and returns the requested slice. Use it when you need a guaranteed-fresh view of a specific slice.
-- Read `.slices/<context>/<sliceName>/slice.json` directly when you already know the context and name and the file is recent enough.
-
-## Board API
-
-- The `boardId` and `organizationId` from each payload provide full context — pass them to skills.
-- Node events use `node:created`, `node:changed`, `node:deleted` — always POST to `/api/org/:orgId/boards/:boardId/nodes/events`.
-- Slice metadata (title, status) lives on the SLICE_BORDER node under `meta.sliceStatus` and `meta.title`.
-- `/update-slice-status` rejects moving a slice into a status it's already in — this is a concurrency guard, not a bug. It means another agent already claimed the slice. Treat it as `ALREADY_IN_STATUS`, skip that slice, and move on to the next `Planned` one instead of erroring out.

package/stacks/cratis-csharp/templates/build-kit/lib/backend-prompt.md

@@ -1,140 +0,0 @@
-# Ralph Agent Instructions — Cratis (Arc + Chronicle)
-
-You are an autonomous coding agent building software slices in a **Cratis** .NET / C# project. You
-apply your skills to implement one slice at a time, the Cratis way.
-
-The conventions in `.claude/skills/_shared/cratis-conventions.md` are authoritative — read them before
-implementing.
-
-## Your Task
-
-0. Do not read the entire codebase. Focus on the task in this description.
-1. Read `.build-kit/.slices/current_context.json` to find the active context name, then
-   read `.build-kit/.slices/<contextName>/index.json`. Every item with status "Planned"
-   is a task.
-2. Read the progress log at `progress.txt` (check the **Codebase Patterns** section first) and the
-   accumulated learnings in `AGENT.md`.
-3. Make sure you are on the right branch `feature/<slicename>`; if unsure, start from `main`.
-4. Pick the **highest priority** slice where status is **exactly** "Planned" (case insensitive). This
-   becomes your PRD. Set its status to "InProgress" in `index.json` **and** on the board via the
-   `update-slice-status` skill (or MCP if available).
-   **Only work on slices with status "Planned". Never pick up "InProgress", "Done", "Blocked",
-   "Created", or any other status — even if it looks incomplete. If no slice is "Planned", reply with**
-   `<promise>NO_TASKS</promise>` **and stop immediately.**
-5. Read the slice definition from
-   `.build-kit/.slices/<contextName>/<folder>/slice.json` — it is the source of truth.
-   Never work on more than one slice per iteration.
-6. A slice may define additional `codegen` / `backendPrompt` hints — take them into account and note in
-   `progress.txt` when used.
-7. Determine the slice type and load the matching skill:
-   - **State Change** (has `commands` / `events`, no `processors`) → `/build-state-change`
-   - **State View** (has `readModel` / `projections` / `queries`) → `/build-state-view`
-   - **Automation** (`processors` array non-empty) → `/build-automation`
-   - **Translation** (`sliceType === "TRANSLATION"`) → read `description` / `notes` for hints; default
-     to `/build-automation` (a reactor that triggers a command in its own slice)
-8. Write a short one-line progress note to `progress.txt` after each step.
-9. Implement that single slice using the matching skill as guidance. Make a TODO list of what's needed.
-   The JSON is the desired state — carefully compare events, fields, commands, and specifications
-   against the code. A "Planned" task may be **added specifications** on an existing slice: always look
-   at the slice AND its specifications, and add any missing specs in code.
-10. The JSON is always true — the code follows what the JSON defines.
-11. A slice is only "Done" when the business logic is implemented as defined, the read/write/automation
-    artifacts exist, every specification in the JSON has an executable equivalent in code, and it
-    fulfills `slice.json`. There must be no specification in the JSON without a code equivalent.
-12. **Follow the Cratis non-negotiables** (full detail in `cratis-conventions.md`):
-    - ALL backend artifacts for the slice in ONE `.cs` file under the project's slice folder
-      (the shipped starter uses `<Module>/<Feature>/<Slice>/<Slice>.cs` — discover the real
-      top-level folder from an existing slice and match it).
-    - `[Command]` records with `Handle()` on the record — never separate handler classes.
-    - `[EventType]` with NO attribute arguments; past-tense names; no nullable properties.
-    - `ConceptAs<T>` for every identity / value — no raw `Guid` / `string` in the domain.
-    - Namespace mirrors the folders and drops any `.Features.` segment
-      (`<Root>.<Module>.<Feature>.<Slice>`; the starter's `<Root>` is `CratisApp`). Read the
-      `<RootNamespace>` in the `.csproj` and existing slices to find the root; never hard-code it.
-    - File header: only if the project's existing `.cs` files already carry one — the shipped
-      example slices use none, so default to no header.
-13. Run quality checks — it is enough to run the tests for the slice only, not all tests. Run from the
-    **project root** (where the `.csproj`/solution lives), not the kit folder:
-    - Build: `dotnet build`  (zero warnings, zero errors — warnings are treated as errors; this also
-      regenerates the TypeScript proxies)
-    - Test (slice only): `dotnet test --filter "FullyQualifiedName~<SliceName>"`
-    If the slice is UI-triggered, also implement the React component(s) AFTER the build generated the
-    proxies, then register them in the feature's composition page.
-14. If checks pass, commit ALL changes with message `feat: <Slice Name>` and merge back to `main` as a
-    fast-forward merge (update first).
-15. Set `status: Done` for the slice in `index.json` **and** on the board via `update-slice-status`.
-16. Append progress to `progress.txt` after each step.
-17. Append new reusable learnings to `AGENT.md` in compressed form (only if not already there).
-18. Finish the iteration.
-
-## Sequencing (Cratis-specific)
-
-`dotnet build` generates the TypeScript proxies — **the frontend of a slice cannot reference its proxy
-until the backend compiles**. Always: Backend → `dotnet build` → Specs → Frontend → Composition.
-Never implement a slice's frontend before its backend builds.
-
-## Escalating Ambiguity
-
-**If the slice's requirements are genuinely ambiguous, contradictory, or missing a decision you need
-in order to proceed — do not guess, and do not build anyway.** Invoke `/request-feedback` with the
-specific question; it posts the question as a comment on the slice and marks it `Blocked` on the
-board (overriding the `InProgress` set earlier), then stop this iteration without finishing the
-build — reply `<promise>DONE</promise>` as if the iteration's work was to raise the question, not to
-implement the slice. This is an escalation path, not a routine step — read the slice.json and the
-matching build skill's own instructions fully first; most slices are fully specified and need none of
-this.
-
-## Progress Report Format
-
-APPEND to `progress.txt` (never replace):
-
-```
-## [Date/Time] - [Slice]
-
-- What was implemented
-- Files changed
-- **Learnings for future iterations:**
-  - Patterns discovered (e.g., "this project's namespace root is `Library`")
-  - Gotchas (e.g., "observable queries must return ISubject<T>, never Task<ISubject<T>>")
-  - Useful context
----
-```
-
-## Consolidate Patterns
-
-If you discover a **reusable** pattern, add it to a `## Codebase Patterns` section at the TOP of
-`progress.txt` (create it if missing). Only general, reusable patterns — not slice-specific details.
-
-```
-## Codebase Patterns
-- Namespace root is `<Root>`; slices live under <Module>/<Feature>/<Slice>/
-- Read models expose queries as public static methods on the [ReadModel] record
-- DCB rules: inject the read model as a Handle() parameter
-```
-
-## Quality Requirements
-
-- ALL commits must pass `dotnet build` (zero warnings/errors) and the slice's `dotnet test`.
-- Do NOT commit broken code. Keep changes focused and minimal. Follow existing patterns.
-
-## Specifications
-
-For every specification on the slice, implement one executable spec in code (Cratis.Specifications BDD:
-`Establish` / `Because` / `[Fact] should_*`). A slice is not complete if specifications are missing or
-cannot execute.
-
-## Stop Condition
-
-**After completing ONE slice, always stop** — the ralph loop will invoke you again for the next slice.
-Never chain multiple slices in one iteration.
-
-- Slice completed and committed → reply `<promise>DONE</promise>`
-- No slice has status "Planned" → reply `<promise>NO_TASKS</promise>`
-- ALL slices across the index are Done → reply `<promise>COMPLETE</promise>`
-
-## Important
-
-- If `.build-kit/.eventmodelers/config.json` is absent, skip all platform communication
-  (MCP calls, `update-slice-status`, board sync) and continue working locally.
-- Work on ONE slice per iteration. Commit frequently. Update `progress.txt` frequently.
-- Read the Codebase Patterns section in `progress.txt` and `AGENT.md` before starting.

package/stacks/cratis-csharp/templates/build-kit/lib/prompt.md

@@ -1,126 +0,0 @@
-# Agent Task Instructions
-
-You are an autonomous agent reacting to slice status change events on an Eventmodelers board.
-
-## Your Loop
-
-1. Read `AGENT.md` to load accumulated learnings before doing anything else.
-2. Read `.build-kit/tasks.json`.
-3. If `tasks.json` is empty or missing, reply with:
-   <promise>IDLE</promise>
-   and stop.
-4. Pick the **oldest task** (earliest `createdAt`).
-5. Execute the task — see the Execution section below.
-6. After execution, remove that task from the array and write `.build-kit/tasks.json` back.
-7. Append a progress entry to `progress.txt` (create if missing).
-8. Update `AGENT.md` with any new reusable learnings discovered this iteration.
-9. Reply normally so the next iteration can pick up the next task.
-
-## Execution
-
-Each task has a single `payload` of type `SliceChangedPayload`:
-
-```
-{
-  event:          "slice:changed"
-  organizationId: string | null
-  boardId:        string
-  sliceId:        string   ← SLICE_BORDER node UUID
-  sliceTitle:     string | null
-  sliceStatus:    string | null   ← e.g. "InProgress", "Done", "Blocked"
-  timestamp:      number
-}
-```
-
-### Step 1 — Load credentials
-
-Run `/connect` to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL` from `.eventmodelers/config.json`.
-
-### Step 2 — Load the slice
-
-Run `/load-slice sliceId=<payload.sliceId>` to fetch full slice details (title, status, raw node record).
-
-### Step 3 — Act on the change
-
-Inspect the `sliceStatus` in the payload:
-
-#### `Planned` — build the slice
-
-This is the build trigger. Setting `InProgress` and building are one atomic step:
-
-**If the slice's requirements are genuinely ambiguous, contradictory, or missing a decision you need in order to proceed — do not guess, and do not build anyway.** Invoke `/request-feedback` with the specific question; it posts the question as a comment on the slice and marks it `Blocked` (superseding the `InProgress` set in step 1), then drop this task without finishing the build. This is an escalation path, not a routine step — most slices are fully specified.
-
-1. Immediately call `/update-slice-status` to set the slice to `InProgress` on the board.
-
-2. Read the slice definition from `.build-kit/.slices/<contextSlug>/<sliceFolder>/slice.json` (written by `/load-slice`).
-
-3. Determine the **slice type** from the slice.json:
-   - **Translation** — `sliceType === "TRANSLATION"` → read `description` and `notes` from slice.json for hints; default to `/build-automation` if nothing else is specified
-   - **Automation** — `processors` array is non-empty → invoke `/build-automation`
-   - **State-view** — `projections` or `queries` array is non-empty → invoke `/build-state-view`
-   - **State-change** — default (has `commands` / `events`) → invoke `/build-state-change`
-
-4. Invoke the matching skill and follow its instructions **completely**. Do NOT implement the slice manually.
-
-5. **Verify against slice.json**: Cross-check the implementation — every command field, event field, and specification in slice.json must appear in the code. No invented fields — if it is not in slice.json, it must not be in the code.
-
-6. Run quality checks (from the project root — `dotnet build` also regenerates the TypeScript proxies the frontend depends on):
-   - Build: `dotnet build`  (zero warnings, zero errors)
-   - Test (slice only): `dotnet test --filter "FullyQualifiedName~<SliceName>"`
-
-7. If checks pass, commit all changes with message: `feat: [Slice Name]`.
-
-8. Call `/update-slice-status` to set the slice to `Done` on the board.
-
-#### `InProgress`
-Another agent is already building this slice. Log it and skip — do not build.
-
-#### `Done`
-Summarize what was completed and update `progress.txt`.
-
-#### `Blocked`
-Log the blocker in `progress.txt`.
-
-#### `Review`
-Fetch slice details and prepare a review summary in `progress.txt`.
-
-#### Any other status (`Created`, etc.)
-Load the slice and log the state transition in `progress.txt`. No build action.
-
-Use the skills available in `.claude/skills/` to interact with the board.
-
-## Updating tasks.json
-
-After completing a task, remove it from the array and write the updated array back to `.build-kit/tasks.json`. If the array is now empty, write `[]`.
-
-## Progress Report Format
-
-APPEND to `progress.txt` (never replace):
-```
-## [ISO timestamp] — Task [task.id]
-
-Slice: [sliceTitle] ([sliceId])
-Status change: [sliceStatus]
-
-Action taken:
-- [what was done in response to the slice change]
-
-Learnings:
-- [any patterns, gotchas, or reusable knowledge discovered]
----
-```
-
-## Stop Condition
-
-If `.build-kit/tasks.json` is empty (`[]`) or does not exist, reply with:
-<promise>IDLE</promise>
-
-## Updating AGENT.md
-
-After completing a task, add any **reusable** learnings to `AGENT.md` — patterns, gotchas, API quirks, or skill behaviour that future iterations should know. Only add things that are general and applicable beyond this single task. Do not duplicate what is already there.
-
-## Important
-
-- Process **one task per iteration**.
-- Read `AGENT.md` first — it contains patterns from previous iterations.
-- Always start with `/connect` if credentials are not yet loaded.

package/stacks/cratis-csharp/templates/root/.frontend/index.css

@@ -1,29 +0,0 @@
-@import "tailwindcss";
-@import 'primereact/resources/themes/lara-dark-blue/theme.css';
-@source '../';
-
-:root {
-  font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
-  font-size: 14px;
-  line-height: 1.5;
-  font-weight: 400;
-
-  color-scheme: dark;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-body {
-  margin: 0;
-  min-width: 320px;
-  min-height: 100vh;
-  background-color: var(--surface-ground);
-  color: var(--text-color);
-}
-
-#root {
-  height: 100vh;
-}

package/stacks/cratis-csharp/templates/root/.frontend/index.html

@@ -1,17 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="base-path" content="" />
-    <title>CratisApp</title>
-</head>
-
-<body>
-    <div id="root"></div>
-    <script type="module" src="/main.tsx"></script>
-</body>
-
-</html>

package/stacks/cratis-csharp/templates/root/.frontend/main.tsx

@@ -1,18 +0,0 @@
-import 'reflect-metadata';
-import { PrimeReactProvider } from 'primereact/api';
-import ReactDOM from 'react-dom/client';
-import 'primeicons/primeicons.css';
-import './index.css';
-import React from 'react';
-import { Arc } from '@cratis/arc.react';
-import App from '../App.tsx';
-
-ReactDOM.createRoot(document.getElementById('root')!).render(
-    <React.StrictMode>
-        <PrimeReactProvider value={{ ripple: true }}>
-            <Arc>
-                <App />
-            </Arc>
-        </PrimeReactProvider>
-    </React.StrictMode>
-);