kagents

.NET application architecture — Modular Monolith, Microservices, Clean Architecture for Blazor, MAUI, ASP.NET Core. Solution structure, architecture pattern decisions, technical design. USE FOR: making architecture decisions, structuring solutions, choosing between architectural patterns. DO NOT USE FOR: writing code (use dotnet-developer) or CI/CD pipeline design (use automation-architect). Read-only — decides, never writes code.

CI/CD pipeline architecture, PowerShell module structure, GitHub Packages, release strategy, workflow run analysis. USE FOR: designing pipelines, structuring automation projects, planning release strategies, analyzing workflow run patterns. DO NOT USE FOR: writing PowerShell code (use powershell-engineer), app architecture (use app-architect), or debugging failed runs (load github-actions-debugging skill). Read-only — defines architecture, never writes code.

Azure resources, .NET Aspire integration, Application Insights, OpenTelemetry, monitoring, logging, alerting — always includes EU-sovereign alternatives with cost comparison. USE FOR: cloud infrastructure design, observability setup, Azure resource provisioning. DO NOT USE FOR: writing .NET application code (use dotnet-developer) or app architecture decisions (use app-architect).

Code review for .NET (C# 14) and PowerShell — architecture conformity, best practices, performance, naming, testability, maintainability. Severity levels: Blocker, Important, Improvement, Note. USE FOR: reviewing code quality, checking architecture conformity, pull request reviews. DO NOT USE FOR: security vulnerability scanning (use security-auditor) or writing/fixing code (use dotnet-developer or powershell-engineer). Read-only — reviews only, never edits code.

EF Core database engineering — DbContext design, entity configuration, migrations, schema design, query optimization, seed data, index design. USE FOR: designing database schemas, creating and reviewing migrations, optimizing queries. DO NOT USE FOR: general .NET development (use dotnet-developer) or security audits (use security-auditor).

Technical documentation — README, API docs, changelogs (Keep a Changelog), release notes, XML-Doc comments (C#), Comment-Based Help (PowerShell), inline documentation. USE FOR: writing READMEs, generating changelogs, documenting APIs, adding XML-Doc or Comment-Based Help. DO NOT USE FOR: writing or reviewing code logic (use dotnet-developer or code-reviewer).

C# 14 / .NET 10 development — Blazor components, MAUI views, ASP.NET Core APIs, services, DTOs, dependency injection, middleware. USE FOR: writing, refactoring, and debugging .NET code across Blazor, MAUI, and ASP.NET Core. DO NOT USE FOR: database schema design (use database-engineer), architecture decisions (use app-architect), or writing tests (use tunit-tester).

Git history analysis — blame, bisect, pickaxe, diff, change tracking, Conventional Commits validation, changelog generation. USE FOR: investigating when, why, and by whom a change was introduced, reviewing commit conventions. DO NOT USE FOR: writing code (use dotnet-developer or powershell-engineer) or release process planning (use planning agent).

Meta-Agent fuer automatisches Routing. Analysiert Aufgaben und delegiert sofort an spezialisierte Agenten. Fuehrt NIEMALS selbst Aufgaben aus.

PowerShell testing with Pester 5.6.x — unit tests, integration tests, infrastructure validation, mocking, InModuleScope, debug-first principle. USE FOR: writing, debugging, and analyzing PowerShell tests with Pester. DO NOT USE FOR: .NET tests (use tunit-tester), writing PowerShell production code (use powershell-engineer), or Blazor UI tests (use tunit-tester with playwright-blazor-testing skill).

Feature planning and GitHub Issue creation — transforms vague requirements into structured GitHub Issues with milestones and user stories. 6-phase workflow: codebase analysis, feature definition, test cases, story cutting, story writing, issue creation. USE FOR: planning features, defining requirements, creating GitHub Issues. DO NOT USE FOR: implementing features (use dotnet-developer or powershell-engineer) or reviewing code (use code-reviewer).

PowerShell Core scripts and modules, GitHub Actions workflows — strictly cross-platform (Windows, Linux, macOS). USE FOR: implementing PowerShell code, CI/CD workflows, and automation scripts. DO NOT USE FOR: PowerShell tests (use pester-tester), pipeline architecture decisions (use automation-architect), or .NET code (use dotnet-developer).

Security analysis — dependency scanning, OWASP Top 10, NuGet vulnerability checks, code security review, severity classification, compliance reporting. USE FOR: scanning for vulnerabilities, auditing dependencies, checking security compliance. DO NOT USE FOR: code quality or architecture review (use code-reviewer) or fixing vulnerabilities (use dotnet-developer or powershell-engineer). Read-only — identifies risks, never fixes code.

.NET testing with TUnit — dual mode: (1) Test Strategist during planning — defines executable test skeletons for GitHub Issues, co-designs test cases. (2) TDD Driver during implementation — Red-Green-Refactor cycle, writes failing tests first. Also classical post-implementation testing. Async assertions, DI fixtures (ClassDataSource), lifecycle hooks, parallel-by-default. Exclusively TUnit — not xUnit, NUnit, or MSTest. USE FOR: TDD workflows, test planning with Planning Agent, writing .NET tests. DO NOT USE FOR: PowerShell tests (use pester-tester) or Aspire integration tests (load aspire-integration-testing skill).

.NET Aspire AppHost, Service Defaults, integrations (Postgres, Redis), service discovery, health checks, Polly resilience, telemetry pipeline. USE FOR: configuring Aspire orchestration, adding service references, setting up cloud-native distributed applications. DO NOT USE FOR: Aspire integration tests (use aspire-integration-testing) or Azure Monitor alerts (use azure-monitoring).

.NET Aspire integration testing — DistributedApplicationTestingBuilder, AppHost test fixtures, service mocking, health check validation, TUnit with ClassDataSource. USE FOR: writing and debugging integration tests against Aspire-orchestrated services. DO NOT USE FOR: Aspire app configuration (use aspire-architecture) or unit tests without Aspire (use tunit-patterns).

Azure Monitor, Application Insights, OpenTelemetry — metrics, traces, logs, custom Meter/Counter/Histogram, SLO-based alerts, Aspire Dashboard. USE FOR: configuring monitoring pipelines, creating alert rules, instrumenting .NET services with OpenTelemetry. DO NOT USE FOR: Aspire AppHost configuration (use aspire-architecture) or general Azure resource provisioning (use azure-specialist agent).

Blazor Server, WASM, Hybrid, Static SSR patterns for .NET 10 — render mode decisions, component architecture, code-behind, state management, EventCallback, cascading values, @key, IDisposable. USE FOR: building Blazor components, choosing render modes, implementing state management. DO NOT USE FOR: Blazor inside MAUI (use maui-blazor-hybrid) or Blazor UI E2E tests (use playwright-blazor-testing).

Conventional Commits — type/scope/description format (feat, fix, docs, refactor, perf, test, chore, ci), breaking changes, scopes (.NET, CI/CD, PowerShell), SemVer mapping. USE FOR: writing commit messages, validating commit format, understanding version-bump rules. DO NOT USE FOR: release process or branching (use releaseflow-domain) or changelog file creation (use release-management).

C# concurrency patterns — async/await, Channel<T>, SemaphoreSlim, CancellationToken, Task.WhenAll, parallel execution, producer/consumer, rate limiting. USE FOR: implementing async workflows, choosing concurrency primitives, fixing deadlocks or async anti-patterns. DO NOT USE FOR: general C# syntax (use csharp-patterns) or EF Core query parallelism (use database-performance).

C# 14 / .NET 10 patterns — primary constructors, collection expressions, pattern matching, records, required members, nullable reference types, file-scoped namespaces, sealed classes, naming conventions. USE FOR: writing modern C# code, applying .NET 10 language features, enforcing naming and style conventions. DO NOT USE FOR: concurrency (use csharp-concurrency-patterns) or EF Core entities (use efcore-patterns).

EF Core query performance — N+1 detection, compiled queries, split queries, query tags, AsNoTracking, index strategy (composite, filtered, covering), read/write DbContext separation. USE FOR: diagnosing slow queries, optimizing EF Core performance, designing database indexes. DO NOT USE FOR: DbContext setup or migrations (use efcore-patterns) or general database schema design (use database-engineer agent).

Native AOT and trimming compatibility for .NET — IL analyzer warnings (IL2026, IL2070, IL2067, IL2072, IL3050), IsAotCompatible, DynamicallyAccessedMembers, source-generated serialization, reflection-free DI. USE FOR: resolving IL warnings, enabling AOT compilation, making libraries trim-safe. DO NOT USE FOR: general build errors (use dotnet-build-diagnosis) or runtime performance tuning (use database-performance or maui-performance).

.NET build error diagnosis — MSBuild (MSB*), NuGet (NU*), SDK (NETSDK*), compiler (CS*) errors, dependency conflicts, restore failures, Central Package Management, Directory.Build.props. USE FOR: diagnosing build failures, resolving NuGet version conflicts, fixing SDK version mismatches. DO NOT USE FOR: IL/AOT warnings (use dotnet-aot-compat) or runtime exceptions (use dotnet-developer agent).

Entity Framework Core for .NET 10 — DbContext design, IEntityTypeConfiguration, Fluent API, migrations, seed data, query patterns (AsNoTracking, Include, projection). USE FOR: designing EF Core entities, creating migrations, writing optimized queries with Fluent API. DO NOT USE FOR: advanced query performance tuning or index strategy (use database-performance).

GitHub Actions debugging — failed workflow analysis, error pattern diagnosis (exit codes, permissions, rate limiting, timeouts), log downloading, matrix failure isolation, gh CLI, debug re-runs. USE FOR: analyzing why a workflow run failed, diagnosing CI performance issues, reading workflow logs. DO NOT USE FOR: creating new workflows or actions (use github-actions-patterns).

GitHub Actions workflow patterns — reusable workflows, composite actions, GitHub App Token, least-privilege permissions, matrix builds, caching, Quality Gate pipelines, pwsh shell. USE FOR: creating CI/CD workflows, optimizing pipeline structure, implementing GitHub Actions best practices. DO NOT USE FOR: analyzing failed workflow runs (use github-actions-debugging) or release branching strategy (use releaseflow-domain).

.NET MAUI accessibility — SemanticProperties, AutomationProperties, screen readers (TalkBack, VoiceOver, Narrator), heading levels, programmatic focus, WCAG 2.1 compliance. USE FOR: making MAUI apps accessible, adding screen reader support, validating WCAG compliance. DO NOT USE FOR: general MAUI UI layout (use maui-patterns) or Blazor accessibility (use blazor-patterns).

Blazor Hybrid in .NET MAUI — BlazorWebView setup, JavaScript-C# interop (IJSRuntime, JSInvokable), shared Razor Class Libraries, platform-specific DI services, CSS isolation, NavigationManager. USE FOR: embedding Blazor in MAUI apps, sharing UI between MAUI and Blazor Web, implementing JS interop. DO NOT USE FOR: standalone Blazor Server/WASM (use blazor-patterns) or general MAUI views (use maui-patterns).

.NET MAUI Hot Reload — C# hot reload, XAML hot reload, Blazor Hybrid hot reload, dotnet watch, MetadataUpdateHandler, hot reload limitations and workarounds. USE FOR: troubleshooting hot reload failures, configuring dotnet watch for MAUI, understanding C# Hot Reload limitations. DO NOT USE FOR: general MAUI development (use maui-patterns) or build errors (use dotnet-build-diagnosis).

.NET MAUI cross-platform patterns — MVVM (CommunityToolkit.Mvvm, ObservableProperty, RelayCommand), Shell navigation, ContentPage, CollectionView, platform-specific partial classes, state management. USE FOR: building MAUI views, implementing MVVM, configuring Shell navigation. DO NOT USE FOR: performance tuning (use maui-performance), accessibility (use maui-accessibility), or Blazor in MAUI (use maui-blazor-hybrid).

.NET MAUI performance — profiling (dotnet trace, dotnet counters), compiled bindings, CollectionView vs ListView, layout optimization, startup time, AOT for Release, PublishTrimmed, image optimization. USE FOR: profiling slow MAUI apps, optimizing layout rendering, reducing startup time, enabling trimming. DO NOT USE FOR: general MAUI patterns (use maui-patterns) or .NET-wide AOT warnings (use dotnet-aot-compat).

ASP.NET Core Minimal API for .NET 10 — MapGroup, endpoint routing, TypedResults, request/response records, IValidator<T>, OpenAPI generation. USE FOR: building REST API endpoints with Minimal API syntax, structuring endpoint groups, implementing request validation. DO NOT USE FOR: Blazor components (use blazor-patterns) or general C# patterns (use csharp-patterns).

OWASP Top 10 for .NET and PowerShell — injection (SQL, XSS, Invoke-Expression), broken access control ([Authorize], CORS), cryptographic failures (bcrypt, no MD5/SHA1), vulnerable dependencies (dotnet audit), SecureString, TLS 1.2+. USE FOR: reviewing code for security vulnerabilities, auditing dependencies, checking OWASP compliance. DO NOT USE FOR: general code quality review (use code-reviewer agent) or dependency updates (use security-auditor agent).

Pester 5.6.x patterns — Describe/Context/It structure, BeforeAll/AfterAll, Mock, InModuleScope, Should assertions, test helpers, GitHub CLI mocking, exit code testing. USE FOR: writing PowerShell tests, mocking commands, testing private module functions with InModuleScope. DO NOT USE FOR: .NET tests (use tunit-patterns) or PowerShell module structure (use powershell-module-design).

Blazor E2E testing with Playwright and TUnit — TUnit.Playwright, browser automation, WebApplication test fixtures, Blazor rendering waits, screenshot capture on failure. USE FOR: writing end-to-end UI tests for Blazor apps, setting up Playwright test fixtures with TUnit. DO NOT USE FOR: Blazor component logic (use blazor-patterns), unit tests (use tunit-patterns), or Aspire integration tests (use aspire-integration-testing).

PowerShell Core module design — .psd1/.psm1 manifests, Public/Private/Handlers folder structure, dot-sourcing order, CmdletBinding, Set-StrictMode, cross-platform rules (no Write-Host, Join-Path), PSScriptAnalyzer. USE FOR: structuring new PowerShell modules, implementing cross-platform functions, writing CI scripts. DO NOT USE FOR: PowerShell tests (use pester-patterns) or GitHub Actions workflows (use github-actions-patterns).

Release execution — SemVer versioning (MAJOR.MINOR.PATCH), pre-release labels (alpha, beta, rc), changelog generation (Keep a Changelog format), git tagging, GitHub Release creation with gh CLI. USE FOR: executing releases, generating changelogs, creating version tags and GitHub Releases. DO NOT USE FOR: ReleaseFlow branching or phase rules (use releaseflow-domain) or commit message format (use conventional-commits).

K.Actions.ReleaseFlow implementation patterns — unified Result-Objects, version-handler pattern, GitHub Actions output helpers, New-TestContext test factory, dot-sourcing conventions, strict mode boilerplate. USE FOR: implementing or modifying K.Actions.ReleaseFlow module code, following ReleaseFlow-specific coding conventions. DO NOT USE FOR: general PowerShell design (use powershell-module-design), general Pester tests (use pester-patterns), or ReleaseFlow process knowledge (use releaseflow-domain).

K.Actions.ReleaseFlow process — branching model (feature → dev → release → main), phases (Alpha, Freeze, Beta, Stable), guardrails G1–G5, release-train planning, feature-freeze enforcement, pre-release tagging, smart tags. USE FOR: understanding ReleaseFlow branching, planning releases, checking phase rules and guardrails. DO NOT USE FOR: changelog/tag creation (use release-management) or modifying ReleaseFlow code (use releaseflow-coding-patterns).

TUnit testing framework — [Test], [Arguments], [MatrixDataSource], ClassDataSource<T> (DI fixtures), async assertions (Assert.That), lifecycle hooks (Before/After), parallel-by-default. USE FOR: writing .NET unit and integration tests with TUnit, structuring test projects, using DI in test fixtures. DO NOT USE FOR: PowerShell tests (use pester-patterns), Blazor E2E tests (use playwright-blazor-testing), or Aspire integration tests (use aspire-integration-testing).

3 hooks across 3 events