cratis

Plugin cratis from marketplace cratis in Cratis/AI. Commands read from the repo's manifest — today.

Skills (156)

• analyzing-dotnet-performance

  Use when reviewing .NET hot paths or scanning source for allocation-heavy and inefficient patterns. Not for measuring a running process, benchmark design or SIMD optimization.

• binlog-generation

  Use when an MSBuild failure or performance investigation needs a binary log and none exists. Not for analyzing existing logs, timing builds or non-MSBuild systems; use msbuild for analysis.

• check-bin-obj-clash

  Use when multi-project or multi-targeted MSBuild builds collide in bin, obj or project.assets.json, overwrite outputs or fail intermittently with file conflicts. Not for OS-only locks or single-project single-TFM builds.

• coverage-analysis

  Use when interpreting supplied .NET coverage evidence or an explicit coverage-collection request. Not for hypothetical change-survival questions, CRAP for one target, writing tests or running tests without a coverage request.

• cratis-application-react-specifications

  Use when specifying a Cratis application's React view-model decisions, command orchestration or narrow component interactions. Not for backend pipeline scenarios or framework-package specifications.

• cratis-application-slice-conformance

  Use when finishing or reviewing hand-written slice code, gap-fill or re-delivery against its accepted model or outline. Not for deciding behavior, writing specifications or running the renderer.

• cratis-application-slice-specifications

  Use when choosing backend plain-call or pipeline-scenario coverage for an event-sourced Cratis application slice. Not for frontend interactions or language-level framework specification mechanics.

• cratis-arc-authentication-authorization-and-identity

  Use when configuring C# Arc authentication, endpoint authorization, identity providers or React identity integration. Not for command validation or Chronicle tenant namespaces alone.

• cratis-arc-code-analysis-typescript

  Use when adding the Arc ESLint plugin to a Node.js server project or fixing an arc-core lint finding such as missing-field, ARC0004 or ARCCHR0006. Not for C# analyzers or runtime build() graph errors.

• cratis-arc-command-execution

  Use when a reactor, job or backend service must execute an existing Arc command without an HTTP request. Not for defining a command or appending another stream's events directly.

• cratis-arc-command-kotlin

  Use when defining a Kotlin or Java Arc command, choosing its handler return shape or returning Chronicle events. Not for validation-only changes or query definitions.

• cratis-arc-command-operation

  Use when moving immediate service writes into returned Arc command operations or diagnosing their compensation and recovery. Not for durable after-commit delivery or validation-only changes.

• cratis-arc-command-typescript

  Use when bootstrapping an Arc Node.js server or defining its TypeScript commands. Not for frontend proxy consumption, validation-only changes or server queries; use the corresponding Arc sibling.

• cratis-arc-command-validation

  Use when adding a business rejection or value invariant to an existing C# Arc command. Not for Kotlin or TypeScript validators, defining a new command or enforcing append-time uniqueness.

• cratis-arc-command

  Use when defining a C# Arc command, choosing its handler return shape or audit exposure (such as API keys or other credentials passed to it), or wiring its generated proxy to a form or button. Not for validation-only changes or executing an existing command.

• cratis-arc-configuration

  Use when choosing, changing or diagnosing C# Arc settings, defaults, ArcOptions, appsettings keys, read protection, MongoDB or EF Core keys, or React provider props. Not for command design, hosting setup or Chronicle kernel settings.

• cratis-arc-ef-core-migration

  Use when adding or changing an EF Core table, column, relationship or index behind an Arc application. Not for Chronicle read-model projections or query paging.

• cratis-arc-elixir

  Use when building an Elixir CQRS application with Arc for Elixir (`cratis_arc`, `cratis_arc_mongodb`) with commands, read-model queries, observable queries over WebSocket or SSE hubs, tenancy, MongoDB, identity, generated TypeScript proxies and vertical slices. Not for the Chronicle client alone, or

• cratis-arc-go

  Use when building an Arc.Go HTTP command or read-model query with handwritten typed adapters and the root module. Not for Chronicle-only clients or unpublished Go integrations and generators.

• cratis-arc-hosting

  Use when creating an Arc .NET host, diagnosing missing endpoints or preparing a trimmed publish. Not for command design, running a Chronicle server or Kotlin and TypeScript hosting.

• cratis-arc-identity-and-tenancy-kotlin

  Use when configuring Kotlin or Java Arc identity endpoints, tenant resolution or trusted ingress. Not for C# Arc identity, command input validation or standalone Chronicle namespaces.

• cratis-arc-neo4j

  Use when an Arc C# query or command must read a Neo4j graph, inject the tenant-aware IGraphSession, run Cypher, or choose the graph database per tenant. Not for projecting events onto a graph or for MongoDB documents.

• cratis-arc-observable-query-http

  Use when inspecting or debugging an existing Arc observable query with curl or another plain HTTP client. Not for implementing the query or its frontend consumer.

• cratis-arc-query-kotlin

  Use when exposing Kotlin or Java Arc read-model queries, including observable streams. Not for commands, Node.js queries or Chronicle event materialization; use the corresponding sibling.

• cratis-arc-query-paging

  Use when an existing Arc list query needs server-side paging or sorting, or a paged query fails with `Expression not supported`. Not for general query creation or a broad performance review.

• cratis-arc-query-typescript

  Use when declaring Arc Node.js read-model queries or observable endpoints. Not for React proxy consumption, server commands or Chronicle event materialization.

• cratis-arc-react-page

  Use when building an Arc React data page, wiring its command dialogs or connecting generated proxies. Not for editing a .play model, theming alone or a standalone wizard dialog.

• cratis-arc-spring-data-kotlin

  Use when wiring Spring Data JPA or MongoDB persistence, current-state injection or storage-backed observations in JVM Arc. Not for Chronicle projections, C# EF Core or query transport alone.

• cratis-arc-storage-typescript

  Use when an Arc Node.js server must read or observe read models in MongoDB or a SQL database through Drizzle. Not for Chronicle projections, query method design or the C# EF Core and MongoDB integrations.

• cratis-arc-tenancy-typescript

  Use when an Arc Node.js server must pick the tenant for each request, prove the caller belongs to it or send data to per-tenant storage. Not for caller authentication, Chronicle namespaces alone or the C# Arc resolver.

• cratis-arc-testing-kotlin

  Use when writing or diagnosing Kotlin or Java Arc pipeline specifications without Spring Boot or a kernel. Not for standalone Chronicle client tests, C# scenarios or defining production commands and queries.

• cratis-arc-testing-typescript

  Use when writing specs for an Arc Node.js server with @cratis/arc.testing, choosing between a direct handle() call and a pipeline scenario or testing routes and authentication. Not for React specs or framework-package tests.

• cratis-arc-validation-kotlin

  Use when adding shared fluent rules or server-side rejection checks to Kotlin or Java Arc commands and queries. Not for C# or Node.js validators, new command definitions or append-time uniqueness.

• cratis-arc-validation-typescript

  Use when adding rejection rules, state checks or validation assertions to an Arc Node.js server. Not for defining commands or queries, C# and JVM validators, or append-time uniqueness.

• cratis-chronicle-cli-operations

  Use when inspecting a running Chronicle store or performing an authorized store operation through the cratis CLI. Not for source-local defects, MCP tool selection or the browser Workbench.

• cratis-chronicle-client-dotnet

  Use when connecting a standalone .NET console, worker or service directly to Chronicle or diagnosing its client lifecycle. Not for Arc integration, kernel implementation or another language's client.

• cratis-chronicle-client-elixir

  Use when adding Chronicle to an Elixir OTP application, defining its event structs, declaring a graph with the node and edge DSL, or handling client append outcomes. Not for JVM or Node.js clients; use the corresponding Chronicle client sibling.

• cratis-chronicle-client-go

  Use when connecting Go to Chronicle, registering client observers or deciding gRPC ownership and append retries. Not for Arc HTTP commands or Chronicle kernel implementation.

• cratis-chronicle-client-kotlin

  Use when connecting a standalone Kotlin or Java application to Chronicle, including client registration and lifecycle issues. Not for Arc commands, Elixir OTP or Node.js clients.

• cratis-chronicle-client-typescript

  Use when connecting a standalone Node.js process to Chronicle or diagnosing its decorators, discovery or client lifecycle. Not for React generated proxies or another language's client.

• cratis-chronicle-compliance

  Use when Chronicle events or read models contain personal data, an erasure subject must be identified or stored events need redaction. Not for authentication, operational secrets or generic data-protection policy.

• cratis-chronicle-configuration

  Use when choosing, changing or diagnosing Chronicle client or kernel settings, defaults, environment variables or the local development loop. Not for production topology (use cratis-chronicle-hosting) or client wiring (use the client skills).

• cratis-chronicle-decision-reads

  Use when a Chronicle write decision must remain valid under concurrent writers, its read scope is unclear or commit read conflicts occur. Not for ordinary query reads or append-time uniqueness alone.

• cratis-chronicle-event-constraints

  Use when Chronicle uniqueness or create-once rules must hold across concurrent appends from every writer. Not for ordinary input validation, capacity predicates or projection creation.

• cratis-chronicle-event-modeling

  Use when hand-written Chronicle behavior, event vocabulary or stream boundaries are unsettled in a code-first repository. Not for opted-in .play model authoring, diagram-only edits or mechanical wiring.

• cratis-chronicle-event-specifications

  Use when specifying Chronicle event appends or constraint violations through the in-process append path. Not for command handling or how events become read-model state.

• cratis-chronicle-event-type-migration

  Use when a Chronicle event schema or value meaning must change after prior events have been stored. Not for disposable greenfield renames, read-model changes or stored-content redaction.

• cratis-chronicle-hosting

  Use when deploying the Chronicle kernel, preparing production topology or diagnosing kernel startup, certificates and clustering. Not for application client wiring, Orleans grain implementation or live-store mutation.

• cratis-chronicle-mcp-inspection

  Use when selecting a Chronicle MCP inspection tool, checking its target and deployment profile or interpreting redacted output. Not for treating job-control tools as read-only inspection or assuming unknown effects are safe.

• cratis-chronicle-multi-tenancy

  Use when selecting Chronicle tenant namespaces, resolving tenant-bound events and read models or adding another tenant. Not for caller authentication, authorization or identity-provider setup.

• cratis-chronicle-projection

  Use when populating an existing Chronicle read model through event mappings, structured joins or lifecycle variants, projecting events onto a graph with nodes and edges, or diagnosing projection startup failures. Not for new query surfaces or external side effects.

• cratis-chronicle-reactor

  Use when Chronicle events must trigger external effects, follow-up commands or translated facts, or a reactor's replay and failure behavior needs diagnosis. Not for populating a queryable read model.

• cratis-chronicle-read-model-specifications

  Use when specifying how Chronicle events become read-model state, including projection or reducer wiring and pure reducer decisions. Not for creating the production model or testing raw event append behavior.

• cratis-chronicle-read-model

  Use when creating a Chronicle read model from scratch or choosing its C# Arc query surface. Not for changing only an existing model's event mappings or state transitions; use the projection or reducer sibling.

• cratis-chronicle-reducer

  Use when a Chronicle read-model transition needs branching, calculations or guards over prior state, or a reducer's discovery and delivery need diagnosis. Not for ordinary event-to-property mappings or external side effects.

• cratis-chronicle-web-workbench

  Use when inspecting Chronicle through its browser Workbench, planning an authorized Workbench operation or deciding whether to expose it. Not for the CLI terminal Workbench or application source changes.

• cratis-ci-pipeline-performance

  Use when GitHub Actions is slow, queues, wastes runner minutes or repeatedly reruns and cancels work. Not for fixing a red build, runtime application performance or release-assurance planning.

• cratis-cli-terminal-workbench

  Use when interactively exploring Chronicle in the CLI terminal Workbench or locating store objects by name. Not for the browser Workbench or scripted and piped inspection.

• cratis-code-review

  Use when reviewing changed Cratis application code for architecture, style and specification coverage beyond compiler checks. Not for a focused security or scalability audit, or for scheduling review rounds.

• cratis-commits-and-pull-requests

  Use before writing commit messages, staging, pushing or creating and editing PRs, including release labels and issue references. Not for candidate assembly, issue status or batching release windows.

• cratis-components-accessibility

  Use when fixing Cratis Components focus, keyboard submission, accessible names, field announcements or decorative icons. Not for claiming general WCAG conformance or choosing a visual theme.

• cratis-components-common-controls

  Use when binding Cratis Components entity pickers, exclusive choices, panel tabs, tag inputs or breadcrumb trails. Not for generated Arc command fields, data tables, canvas palettes or theming.

• cratis-components-data-surfaces

  Use when a Cratis UI needs pivot exploration, historical snapshots, a pan/zoom board or host-owned chat views. Not for DataPage lists, event replay, chat persistence, tool palettes or Scene authoring.

• cratis-components-schema-editor

  Use when building a Cratis UI to edit a schema's structure or inspect and edit object data against a schema. Not for forms bound to generated Arc commands; use cratis-arc-react-page.

• cratis-components-stepper-command-dialog
• cratis-components-styling
• cratis-components-toolbar
• cratis-content-length
• cratis-developer-marketing
• cratis-discoverability
• cratis-documentation-writing
• cratis-engineering-ci-gates
• cratis-engineering-consolidation-guard
• cratis-engineering-csharp-conventions
• cratis-engineering-decision-record
• cratis-engineering-docs-authoring
• cratis-engineering-effect-boundaries
• cratis-engineering-issue-design-note
• cratis-engineering-issue-hygiene
• cratis-engineering-local-cross-repo-verification
• cratis-engineering-regression-cluster
• cratis-engineering-release-trains
• cratis-engineering-review-rounds
• cratis-environments-and-secrets
• cratis-event-model-diagram
• cratis-fundamentals-concept-go
• cratis-fundamentals-concept
• cratis-fundamentals-telemetry
• cratis-fundamentals-type-discovery
• cratis-governed-release-methodology
• cratis-lens-browser-extension
• cratis-llm-friendly-documentation
• cratis-multi-service-architecture
• cratis-multi-service-local-orchestration
• cratis-onboarding-runtime
• cratis-orchestration-lanes
• cratis-orchestration-merge-gates
• cratis-orleans-jobs
• cratis-performance-review
• cratis-release-notes
• cratis-rtk
• cratis-screenplay-authentication-and-onboarding
• cratis-screenplay-automations-and-translations
• cratis-screenplay-availability
• cratis-screenplay-captures-and-reactions
• cratis-screenplay-command-surface
• cratis-screenplay-delivery-planning
• cratis-screenplay-discovery
• cratis-screenplay-event-modeling
• cratis-screenplay-extension-packages
• cratis-screenplay-legacy-extraction
• cratis-screenplay-model-authoring
• cratis-screenplay-model-review
• cratis-screenplay-modeling-lifecycle
• cratis-screenplay-projections
• cratis-screenplay-read-surface
• cratis-screenplay-render-and-gap-fill
• cratis-screenplay-reverse-engineering
• cratis-screenplay-scenario-coverage
• cratis-screenplay-slice-design
• cratis-screenplay-specifications
• cratis-screenplay-streams-and-consistency
• cratis-screenplay-toolchain
• cratis-screenplay-ui-composition
• cratis-security-review
• cratis-session-handoff
• cratis-showrunner-herald
• cratis-social-feed-post
• cratis-specification-by-example
• cratis-specifications-csharp
• cratis-specifications-typescript
• cratis-stage-rendering-and-sandbox
• cratis-studio-mcp-safety-guidance
• cratis-technical-examples
• cratis-writing-voice-and-cadence
• csharp-refactoring
• directory-build-organization
• dotnet-aot-compat
• dotnet-trace-collect
• dump-collect
• eliminate-redundant-restores
• extension-points
• filter-syntax
• guiding-refactoring-with-code-health
• including-generated-files
• microbenchmarking
• msbuild
• orleans
• platform-detection
• prioritizing-technical-debt
• profiling
• risk-based-testing-with-code-health
• run-tests
• safeguarding-ai-generated-code
• target-authoring
• vectorization

Subagents (16)

• Backend Developer

  Specialist for C# backend code within a vertical slice. Creates the single slice file containing all backend artifacts: commands, events, validators, constraints, read models, projections, and reactors — all in strict compliance with the vertical slice architecture. - Read - Grep - Glob - Bash - Edi

• Browser Operator

  Read-only browser agent. The only agent type given browser tools. Runs a scoped UI check or production smoke against a named URL and returns an evidence record. Never edits source. - Read - Grep - Glob - Bash

• Code Reviewer

  Quality gate agent for Cratis-based projects. Reviews code against all project instruction files, checking architecture conformance, C# and TypeScript conventions, and vertical slice correctness before merge. - Read - Grep - Glob - Bash

• Coordinator

  General-purpose coordinator agent for Cratis-based projects. Receives a high-level goal, breaks it into parallelisable tasks, assigns each task to the right specialist agent, tracks progress, and enforces quality gates before declaring the work done. Use this agent when a request spans multiple conc

• Frontend Developer

  Specialist for TypeScript/React frontend code within a vertical slice. Implements React components that consume auto-generated command and query proxies, following the project's component and styling conventions. - Read - Grep - Glob - Bash - Edit - Write

• Orchestrator

  Top-level team orchestrator for Cratis-based projects. Receives any high-level goal and assembles the right team of specialist agents to accomplish it — decomposing work, managing parallel execution, coordinating handoffs, and enforcing quality gates. Use this agent as the entry point whenever multi

• Performance Reviewer

  Performance-focused review agent for Cratis-based projects. Analyzes changed files for projection efficiency, query patterns, unnecessary allocations, React render overhead, and Chronicle anti-patterns before merge. - Read - Grep - Glob - Bash

• Vertical Slice Planner

  Orchestrates the implementation of one or more vertical slices. Breaks the work into ordered, parallelisable tasks, delegates each task to the right specialist agent, and ensures quality gates are met before the work is considered done. - Read - Grep - Glob - Bash - Agent

• Repository Investigation Reviewer

  Independent, read-only reviewer for typed Cratis repository investigations. Reviews evidence and repository-mode reasoning without applying application conventions to framework or client-library repositories. - Read - Grep - Glob

• Repository Investigator

  Read-only investigator for Cratis application and framework repositories. Produces typed, evidence-backed findings without changing source, invoking mutating Chronicle operations, or assuming an application architecture. - Read - Grep - Glob - Bash

• Screenplay Modeler

  Model-first author for Cratis Screenplay (.play) models: discovers domains, designs slices, streams, automations, translations and specifications, extracts models from legacy systems, validates every coherent change, and hands off a packet. Use for new models, model changes, post-review fixes and le

• Screenplay Renderer

  Capability probe and delivery verifier for accepted Cratis Screenplay models: checks admission, renders with the cratis CLI into a probe destination, builds and tests the generated output, maps results to .play specifications, and classifies model fixes against platform gaps. Never edits .play or St

• Screenplay Reviewer

  Read-only independent reviewer for Cratis Screenplay (.play) models, extracted candidates and change requests. Critic mode checks lineage, structure, anti-patterns, scenario coverage, event-sourcing correctness and mode compliance; explain mode asks the business questions in plain language. Returns

• Security Reviewer

  Security gate agent for Cratis-based projects. Performs a structured security review of all changed files before merge, covering input validation, auth/authz, data exposure, secrets, event sourcing specifics, and frontend attack surface. - Read - Grep - Glob - Bash

• Slice Implementer

  Implements a Cratis vertical slice end-to-end — all backend artifacts in one slice file, BDD specs in when_*/ folders, and the React surface (page and/or command dialog). Use for new slices and for non-trivial slice changes spanning backend and frontend. - Read - Grep - Glob - Bash - Edit - Write

• Spec Writer

  Specialist for writing C# specs (plain calls and focused in-process scenarios) and TypeScript/React specs for vertical slices. Ensures every slice has comprehensive behavior coverage following the project's BDD conventions. - Read - Grep - Glob - Bash - Edit - Write

Similar plugins