minor fix (#2235)

Author: david-driscoll

.agents/skills/aspnet-minimal-api-openapi/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: aspnet-minimal-api-openapi
+description: 'Create ASP.NET Minimal API endpoints with proper OpenAPI documentation'
+---
+
+# ASP.NET Minimal API with OpenAPI
+
+Your goal is to help me create well-structured ASP.NET Minimal API endpoints with correct types and comprehensive OpenAPI/Swagger documentation.
+
+## API Organization
+
+- Group related endpoints using `MapGroup()` extension
+- Use endpoint filters for cross-cutting concerns
+- Structure larger APIs with separate endpoint classes
+- Consider using a feature-based folder structure for complex APIs
+
+## Request and Response Types
+
+- Define explicit request and response DTOs/models
+- Create clear model classes with proper validation attributes
+- Use record types for immutable request/response objects
+- Use meaningful property names that align with API design standards
+- Apply `[Required]` and other validation attributes to enforce constraints
+- Use the ProblemDetailsService and StatusCodePages to get standard error responses
+
+## Type Handling
+
+- Use strongly-typed route parameters with explicit type binding
+- Use `Results<T1, T2>` to represent multiple response types
+- Return `TypedResults` instead of `Results` for strongly-typed responses
+- Leverage C# 10+ features like nullable annotations and init-only properties
+
+## OpenAPI Documentation
+
+- Use the built-in OpenAPI document support added in .NET 9
+- Define operation summary and description
+- Add operationIds using the `WithName` extension method
+- Add descriptions to properties and parameters with `[Description()]`
+- Set proper content types for requests and responses
+- Use document transformers to add elements like servers, tags, and security schemes
+- Use schema transformers to apply customizations to OpenAPI schemas

.agents/skills/context-map/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: context-map
+description: 'Generate a map of all files relevant to a task before making changes'
+---
+
+# Context Map
+
+Before implementing any changes, analyze the codebase and create a context map.
+
+## Task
+
+{{task_description}}
+
+## Instructions
+
+1. Search the codebase for files related to this task
+2. Identify direct dependencies (imports/exports)
+3. Find related tests
+4. Look for similar patterns in existing code
+
+## Output Format
+
+```markdown
+## Context Map
+
+### Files to Modify
+| File | Purpose | Changes Needed |
+|------|---------|----------------|
+| path/to/file | description | what changes |
+
+### Dependencies (may need updates)
+| File | Relationship |
+|------|--------------|
+| path/to/dep | imports X from modified file |
+
+### Test Files
+| Test | Coverage |
+|------|----------|
+| path/to/test | tests affected functionality |
+
+### Reference Patterns
+| File | Pattern |
+|------|---------|
+| path/to/similar | example to follow |
+
+### Risk Assessment
+- [ ] Breaking changes to public API
+- [ ] Database migrations needed
+- [ ] Configuration changes required
+```
+
+Do not proceed with implementation until this map is reviewed.

.agents/skills/context7-mcp/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: context7-mcp
+description: This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.
+---
+
+When the user asks about libraries, frameworks, or needs code examples, use Context7 to fetch current documentation instead of relying on training data.
+
+## When to Use This Skill
+
+Activate this skill when the user:
+
+- Asks setup or configuration questions ("How do I configure Next.js middleware?")
+- Requests code involving libraries ("Write a Prisma query for...")
+- Needs API references ("What are the Supabase auth methods?")
+- Mentions specific frameworks (React, Vue, Svelte, Express, Tailwind, etc.)
+
+## How to Fetch Documentation
+
+### Step 1: Resolve the Library ID
+
+Call `resolve-library-id` with:
+
+- `libraryName`: The library name extracted from the user's question
+- `query`: The user's full question (improves relevance ranking)
+
+### Step 2: Select the Best Match
+
+From the resolution results, choose based on:
+
+- Exact or closest name match to what the user asked for
+- Higher benchmark scores indicate better documentation quality
+- If the user mentioned a version (e.g., "React 19"), prefer version-specific IDs
+
+### Step 3: Fetch the Documentation
+
+Call `query-docs` with:
+
+- `libraryId`: The selected Context7 library ID (e.g., `/vercel/next.js`)
+- `query`: The user's specific question
+
+### Step 4: Use the Documentation
+
+Incorporate the fetched documentation into your response:
+
+- Answer the user's question using current, accurate information
+- Include relevant code examples from the docs
+- Cite the library version when relevant
+
+## Guidelines
+
+- **Be specific**: Pass the user's full question as the query for better results
+- **Version awareness**: When users mention versions ("Next.js 15", "React 19"), use version-specific library IDs if available from the resolution step
+- **Prefer official sources**: When multiple matches exist, prefer official/primary packages over community forks

.agents/skills/csharp-async/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: csharp-async
+description: 'Get best practices for C# async programming'
+---
+
+# C# Async Programming Best Practices
+
+Your goal is to help me follow best practices for asynchronous programming in C#.
+
+## Naming Conventions
+
+- Use the 'Async' suffix for all async methods
+- Match method names with their synchronous counterparts when applicable (e.g., `GetDataAsync()` for `GetData()`)
+
+## Return Types
+
+- Return `Task<T>` when the method returns a value
+- Return `Task` when the method doesn't return a value
+- Consider `ValueTask<T>` for high-performance scenarios to reduce allocations
+- Avoid returning `void` for async methods except for event handlers
+
+## Exception Handling
+
+- Use try/catch blocks around await expressions
+- Avoid swallowing exceptions in async methods
+- Use `ConfigureAwait(false)` when appropriate to prevent deadlocks in library code
+- Propagate exceptions with `Task.FromException()` instead of throwing in async Task returning methods
+
+## Performance
+
+- Use `Task.WhenAll()` for parallel execution of multiple tasks
+- Use `Task.WhenAny()` for implementing timeouts or taking the first completed task
+- Avoid unnecessary async/await when simply passing through task results
+- Consider cancellation tokens for long-running operations
+
+## Common Pitfalls
+
+- Never use `.Wait()`, `.Result`, or `.GetAwaiter().GetResult()` in async code
+- Avoid mixing blocking and async code
+- Don't create async void methods (except for event handlers)
+- Always await Task-returning methods
+
+## Implementation Patterns
+
+- Implement the async command pattern for long-running operations
+- Use async streams (IAsyncEnumerable<T>) for processing sequences asynchronously
+- Consider the task-based asynchronous pattern (TAP) for public APIs
+
+When reviewing my C# code, identify these issues and suggest improvements that follow these best practices.