diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
deleted file mode 100644
index 13447bd4..00000000
--- a/.github/copilot-instructions.md
+++ /dev/null
@@ -1,193 +0,0 @@
-# Copilot Instructions
-
-**Last updated:** June 12, 2025
-
-These instructions define the required coding, architecture, and project rules for all .NET code in this repository.
-They are based on the actual practices and conventions in the TailwindBlogApp solution. For more details,
-see [CONTRIBUTING.md](../docs/CONTRIBUTING.md).
-
----
-
-## Technology Stack (Required)
-
-### Framework and Language Versions
-
-- **.NET Version:** `10.0` (latest stable)
- - All projects must target .NET 10
- - Use the latest stable runtime and SDK
-- **C# Language Version:** `14.0` (latest stable)
- - Leverage latest language features when appropriate
- - Configure via `14.0` in project files or Directory.Build.props
-- **API Documentation:** `Scalar` with `OpenAPI 3.0+`
- - Use Scalar for interactive API documentation
- - All REST APIs must expose OpenAPI specifications
- - See Documentation section for additional requirements
-
-### Platform Requirements
-
-- **Minimum SDK:** `.NET 10 SDK`
-- **Target Framework:** `net10.0`
-- **Runtime:** `.NET 10 Runtime` (latest stable patch version)
-
----
-
-## C# (Required)
-
-### Style
-
-- **Use .editorconfig:** `true`
-- **Use Tailwindcss:** `true`
-- **Preferred Modifier Order:** `public`, `private`, `protected`, `internal`, `static`, `readonly`, `const`
- - _Example:_
-
- ```csharp
- public static readonly int MY_CONST = 42;
-
-```text
-
-- **Use Explicit Type:** `true` (except where `var` improves clarity)
-- **Use Var:** `true` (when the type is obvious)
-- **Prefer Null Check:**
- - Use `is null`: `true`
- - Use `is not null`: `true`
-- **Prefer Primary Constructors:** `false`
-- **Prefer Records:** `true`
-- **Prefer Minimal APIs:** `true`
-- **Prefer File Scoped Namespaces:** `true`
-- **Use Global Usings:** `true` (see `GlobalUsings.cs` in each project)
-- **Use Nullable Reference Types:** `true`
-- **Use Pattern Matching:** `true`
-- **Max Line Length:** `120`
-- **Indent Style:** `tab`
-- **Indent Size:** `2`
-- **End of Line:** `lf`
-- **Trim Trailing Whitespace:** `true`
-- **Insert Final Newline:** `true`
-- **Charset:** `utf-8`
-
-### Naming
-
-- **Interface Prefix:** `I` (e.g., `IService`)
-- **Async Suffix:** `Async` (e.g., `GetDataAsync`)
-- **Private Field Prefix:** `_` (e.g., `_myField`)
-- **Constant Case:** `UPPER_CASE` (e.g., `MAX_SIZE`)
-- **Component Suffix:** `Component` (for Blazor components)
-- **Blazor Page Suffix:** `Page` (for Blazor pages)
-
-### Security (Required)
-
-- **Require HTTPS:** `true` (see `Web/Program.cs`)
-- **Require Authentication:** `true` (Auth0 integration, see `README.md`)
-- **Require Authorization:** `true`
-- **Use Antiforgery Tokens:** `true` (see `Web/Program.cs`)
-- **Use CORS:** `true`
-- **Use Secure Headers:** `true`
-
-### Architecture (Required)
-
-- **Enforce Aspire:** `true` (see `AppHost/`, `README.md`)
-- **Enforce SOLID:** `true` (see `Domain/`, `ServiceDefaults/`)
-- **Enforce Dependency Injection:** `true` (see `Web/Program.cs`, `ServiceDefaults/`)
-- **Enforce Async/Await:** `true` (async methods and tests)
-- **Enforce Strongly Typed Config:** `true`
-- **Enforce CQRS:** `true` (see `Domain/Abstractions/`, `MediatR` usage)
-- **Enforce Unit Tests:** `true` (see `Tests/`)
-- **Enforce Integration Tests:** `true` (see `Tests/`)
-- **Enforce Architecture Tests:** `true` (see `Tests/Architecture.Tests/`)
-- **Enforce Vertical Slice Architecture:** `true`
-- **Centralize NuGet Package Versions:** `true` (all package versions must be managed in `Directory.Packages.props` at
- the repo root; do not specify versions in individual project files)
-
-### Blazor (Required)
-
-- **Enforce State Management:** `true` (see use of `@code` blocks and parameters)
-- **Use Interactive Server Rendering:** `true` (see `Web/Program.cs`)
-- **Use Stream Rendering:** `true`
-- **Enforce Component Lifecycle:** `true` (see `OnInitialized`, `OnParametersSet` in components)
-- **Use Cascading Parameters:** `true` (see shared layout/components)
-- **Use Render Fragments:** `true` (see component parameters)
-- **Use Virtualization:** `true` (see use of `Web.Virtualization`)
-- **Use Error Boundaries:** `true` (see `MainLayout.razor` error UI)
-- **Component Suffix:** `Component` (e.g., `FooterComponent`)
-- **Page Suffix:** `Page` (e.g., `AboutPage`)
-
-### Documentation (Required)
-
-- **Require XML Docs:** `true` (see `` in test and code files)
-- **Require Scalar:** `true` (Scalar is the required API documentation tool; use instead of Swagger UI)
-- **Require OpenAPI:** `true` (OpenAPI 3.0+ specifications must be provided for all REST APIs)
-- **Use Scalar for API Explorer:** `true` (interactive API documentation via Scalar, not Swagger UI)
-- **Require Component Documentation:** `true` (see `` in Blazor tests)
-- **Require README:** `true` (see `README.md`, `docs/README.md`)
-- **Require CONTRIBUTING.md:** `true` (see `docs/CONTRIBUTING.md`)
-- **Require LICENSE:** `true` (see `LICENSE`)
-- **Require Code of Conduct:** `true` (see `CODE_OF_CONDUCT.md`)
-- **Require File Copyright Headers:** `true`
-
-### Logging (Required)
-
-- **Require Structured Logging:** `true`
-- **Require Health Checks:** `true`
-- **Use OpenTelemetry:** `true`
-- **Use Application Insights:** `true`
-
-### Database (Required)
-
-- **Use Entity Framework Core:** `true`
-- **Use MongoDB:** `true` (see `Persistence.MongoDb/`)
-- **Use MongoDB.Driver:** `true`
-- **Use MongoDB.EntityFrameworkCore:** `true`
-- **Prefer Async Operations:** `true`
-- **Use TestContainers:** `true` (for Integration testing, see `Tests/`)
-- **Use Change Tracking:** `true`
-- **Use DbContext Pooling:** `true`
-- **Use DbContext Factory:** `true`
-- **Use In-Memory Database:** `false`
-
-### Versioning (Required)
-
-- **Require API Versioning:** `true`
-- **Use Semantic Versioning:** `true`
-
-### Caching (Required)
-
-- **Require Caching Strategy:** `true`
-- **Use Distributed Cache:** `true`
-- **Use Output Caching:** `true` (see `Web/Program.cs`)
-
-### Middleware (Required)
-
-- **Require Cross-Cutting Concerns:** `true`
-- **Use Exception Handling:** `true` (see `Web/Program.cs`)
-- **Use Request Logging:** `true`
-
-### Background Services (Required)
-
-- **Require Background Service:** `true`
-
-### Environment (Required)
-
-- **Require Environment Config:** `true`
-- **Use User Secrets:** `true`
-- **Use Key Vault:** `true`
-
-### Validation (Required)
-
-- **Require Model Validation:** `true`
-- **Use FluentValidation:** `true`
-
-### Testing (Required)
-
-- **Require Unit Tests:** `true` (see `Tests/`)
-- **Require Integration Tests:** `true` (see `Tests/`)
-- **Require Architecture Tests:** `true` (see `Tests/Architecture.Tests/`)
-- **Use xUnit:** `true` (see `Tests/`)
-- **Use FluentAssertions:** `true` (see `Tests/`)
-- **Use NSubstitute:** `true`
-- **Use bUnit:** `true` (see `Tests/Web.Tests.Bunit/`)
-- **Use Playwright:** `true` (see `README.md`)
-
----
-
-**Note:** These rules are enforced via `.editorconfig`, StyleCop, and other tooling where possible. For questions or
-clarifications, see [CONTRIBUTING.md](../docs/CONTRIBUTING.md).
diff --git a/.github/instructions/blazor.instructions.md b/.github/instructions/blazor.instructions.md
index 5113943c..0c3dc6d0 100644
--- a/.github/instructions/blazor.instructions.md
+++ b/.github/instructions/blazor.instructions.md
@@ -3,75 +3,57 @@ description: 'Blazor component and application patterns'
applyTo: '**/*.razor, **/*.razor.cs, **/*.razor.css'
---
-## Blazor Code Style and Structure
+# Blazor Instructions
-- Write idiomatic and efficient Blazor and C# code.
-- Follow .NET and Blazor conventions.
-- Use Razor Components appropriately for component-based UI development.
-- Prefer inline functions for smaller components but separate complex logic into code-behind or service classes.
-- Async/await should be used where applicable to ensure non-blocking UI operations.
+IssueTracker's UI is a Blazor Server app (`src/UI/IssueTracker.UI`) on .NET 10 and C# 14.
+`CLAUDE.md` at the repository root describes the project; if this file and it disagree, it wins.
-## Naming Conventions
+## Structure
-- Follow PascalCase for component names, method names, and public members.
-- Use camelCase for private fields and local variables.
-- Prefix interface names with "I" (e.g., IUserService).
+- `Pages/` holds routable pages, `Components/` reusable pieces such as `IssueComponent` and `CommentComponent`,
+ and `Shared/` the layout, login display and authorization redirects.
+- Components keep markup in `.razor` and logic in a `.razor.cs` code-behind partial class. Keep `@code` blocks out of
+ new components.
+- Get services with `@inject` at the top of the `.razor` file, as the existing components do. Never `new` them up.
+- Register new services in the matching `Extensions/Register*.cs` file, not in `Program.cs`.
-## Blazor and .NET Specific Guidelines
+## Rendering
-- Utilize Blazor's built-in features for component lifecycle (e.g., OnInitializedAsync, OnParametersSetAsync).
-- Use data binding effectively with @bind.
-- Leverage Dependency Injection for services in Blazor.
-- Structure Blazor components and services following Separation of Concerns.
-- Always use the latest version C#, currently C# 13 features like record types, pattern matching, and global usings.
+- `Pages/_Host.cshtml` hosts the app and `MapBlazorHub` serves it, so every component is interactive over the SignalR circuit.
+- Load data in `OnInitializedAsync` or `OnParametersSetAsync`, not in constructors.
+- Don't call JavaScript interop during initialization or prerendering: do first-load interop in `OnAfterRenderAsync`,
+ guarding one-time setup with `if (firstRender)`. Event handlers can call it freely, as `Index.razor.cs` does when it
+ saves the filters to session storage.
+- Implement `IDisposable` or `IAsyncDisposable` to release event subscriptions, timers, and `CancellationTokenSource`s.
-## Error Handling and Validation
+## Data
-- Implement proper error handling for Blazor pages and API calls.
-- Use logging for error tracking in the backend and consider capturing UI-level errors in Blazor with tools like ErrorBoundary.
-- Implement validation using FluentValidation or DataAnnotations in forms.
+- Components call the services in `IssueTracker.Services` (`IIssueService`, `ICommentService`, and so on).
+ Never inject a repository or anything from MongoDB into a component. No test catches this, so reviews must.
+- Components display the CoreBusiness models (`IssueModel`, `BasicUserModel`, ...). Forms bind to the DTOs in the UI's
+ `Models/` folder (`CreateIssueDto`, `CreateCommentDto`), so UI-only fields and validation stay out of CoreBusiness.
-## Blazor API and Performance Optimization
+## Forms and validation
-- Utilize Blazor server-side or WebAssembly optimally based on the project requirements.
-- Use asynchronous methods (async/await) for API calls or UI actions that could block the main thread.
-- Optimize Razor components by reducing unnecessary renders and using StateHasChanged() efficiently.
-- Minimize the component render tree by avoiding re-renders unless necessary, using ShouldRender() where appropriate.
-- Use EventCallbacks for handling user interactions efficiently, passing only minimal data when triggering events.
+- Use `EditForm` bound to a DTO, ``, and Radzen validators (`RadzenRequiredValidator`,
+ `RadzenLengthValidator`) where the form uses Radzen inputs.
+- Validate again in the service before acting on a submission. Never trust client-side validation alone.
-## Caching Strategies
+## Security
-- Implement in-memory caching for frequently used data, especially for Blazor Server apps. Use IMemoryCache for lightweight caching solutions.
-- For Blazor WebAssembly, utilize localStorage or sessionStorage to cache application state between user sessions.
-- Consider Distributed Cache strategies (like Redis or SQL Server Cache) for larger applications that need shared state across multiple users or clients.
-- Cache API calls by storing responses to avoid redundant calls when data is unlikely to change, thus improving the user experience.
+- Authentication is Azure AD B2C through Microsoft.Identity.Web. `Shared/LoginDisplay.razor` links to the
+ `MicrosoftIdentity/Account/SignIn` and `SignOut` endpoints.
+- Protect pages with `@attribute [Authorize]`, adding `Policy = "Admin"` for admin pages as `Admin.razor` does.
+ `` only shows or hides UI and isn't a security boundary.
+- Get the signed-in user with `AuthenticationStateProviderHelpers.GetUserFromAuth`, which loads the matching `UserModel`.
-## State Management Libraries
+## Styling
-- Use Blazor's built-in Cascading Parameters and EventCallbacks for basic state sharing across components.
-- Implement advanced state management solutions using libraries like Fluxor or BlazorState when the application grows in complexity.
-- For client-side state persistence in Blazor WebAssembly, consider using Blazored.LocalStorage or Blazored.SessionStorage to maintain state between page reloads.
-- For server-side Blazor, use Scoped Services and the StateContainer pattern to manage state within user sessions while minimizing re-renders.
+- Use Radzen.Blazor components for grids, buttons and inputs, and Bootstrap classes for layout.
+- Put site-wide rules in `wwwroot/css/site.css` and Bootstrap overrides in `wwwroot/css/bootstrap-overrides.css`.
+- Use `.razor.css` isolation for styles that belong to one component. Avoid inline `style` attributes.
-## API Design and Integration
+## Testing
-- Use HttpClient or other appropriate services to communicate with external APIs or your own backend.
-- Implement error handling for API calls using try-catch and provide proper user feedback in the UI.
-
-## Testing and Debugging in Visual Studio
-
-- All unit testing and integration testing should be done in Visual Studio Enterprise.
-- Test Blazor components and services using xUnit, NUnit, or MSTest.
-- Use Moq or NSubstitute for mocking dependencies during tests.
-- Debug Blazor UI issues using browser developer tools and Visual Studio's debugging tools for backend and server-side issues.
-- For performance profiling and optimization, rely on Visual Studio's diagnostics tools.
-
-## Security and Authentication
-
-- Implement Authentication and Authorization in the Blazor app where necessary using ASP.NET Identity or JWT tokens for API authentication.
-- Use HTTPS for all web communication and ensure proper CORS policies are implemented.
-
-## API Documentation and Swagger
-
-- Use Swagger/OpenAPI for API documentation for your backend API services.
-- Ensure XML documentation for models and API methods for enhancing Swagger documentation.
+- Test components with bUnit in `tests/IssueTracker.UI.Tests.Unit`, following the Tests section of `CLAUDE.md`.
+- New tests use `BunitContext`, not the obsolete `TestContext` that the existing tests still use.
diff --git a/.github/instructions/blog.instructions.md b/.github/instructions/blog.instructions.md
new file mode 100644
index 00000000..f2b3c897
--- /dev/null
+++ b/.github/instructions/blog.instructions.md
@@ -0,0 +1,19 @@
+---
+description: 'Front matter required for blog posts'
+applyTo: 'docs/blogs/**/*.md'
+---
+
+# Blog Post Instructions
+
+Follow `markdown.instructions.md`. In addition, start every post with YAML front matter containing:
+
+- `post_title`: the post's title.
+- `author1`: the primary author.
+- `post_slug`: the URL slug.
+- `microsoft_alias`: the author's Microsoft alias, or `n/a` when there is none.
+- `featured_image`: the URL of the featured image.
+- `categories`: the post's categories.
+- `tags`: the post's tags.
+- `ai_note`: whether AI was used to write the post.
+- `summary`: a short summary of the post.
+- `post_date`: the publication date.
diff --git a/.github/instructions/copilot-instructions.md b/.github/instructions/copilot-instructions.md
deleted file mode 100644
index 438e0f20..00000000
--- a/.github/instructions/copilot-instructions.md
+++ /dev/null
@@ -1,190 +0,0 @@
-# Copilot Instructions
-
-**Last updated:** June 12, 2025
-
-These instructions define the required coding, architecture, and project rules for all .NET code in this repository. They are based on the actual practices and conventions in the TailwindBlogApp solution. For more details, see [CONTRIBUTING.md](../docs/CONTRIBUTING.md).
-
----
-
-## Technology Stack (Required)
-
-### Framework and Language Versions
-
-- **.NET Version:** `10.0` (latest stable)
- - All projects must target .NET 10
- - Use the latest stable runtime and SDK
-- **C# Language Version:** `14.0` (latest stable)
- - Leverage latest language features when appropriate
- - Configure via `14.0` in project files or Directory.Build.props
-- **API Documentation:** `Scalar` with `OpenAPI 3.0+`
- - Use Scalar for interactive API documentation
- - All REST APIs must expose OpenAPI specifications
- - See Documentation section for additional requirements
-
-### Platform Requirements
-
-- **Minimum SDK:** `.NET 10 SDK`
-- **Target Framework:** `net10.0`
-- **Runtime:** `.NET 10 Runtime` (latest stable patch version)
-
----
-
-## C# (Required)
-
-### Style
-
-- **Use .editorconfig:** `true`
-- **Preferred Modifier Order:** `public`, `private`, `protected`, `internal`, `static`, `readonly`, `const`
- - _Example:_
-
- ```csharp
- public static readonly int MY_CONST = 42;
-
-```text
-
-- **Use Explicit Type:** `true` (except where `var` improves clarity)
-- **Use Var:** `true` (when the type is obvious)
-- **Prefer Null Check:**
- - Use `is null`: `true`
- - Use `is not null`: `true`
-- **Prefer Primary Constructors:** `false`
-- **Prefer Records:** `true`
-- **Prefer Minimal APIs:** `true`
-- **Prefer File Scoped Namespaces:** `true`
-- **Use Global Usings:** `true` (see `GlobalUsings.cs` in each project)
-- **Use Nullable Reference Types:** `true`
-- **Use Pattern Matching:** `true`
-- **Max Line Length:** `120`
-- **Indent Style:** `tab`
-- **Indent Size:** `2`
-- **End of Line:** `lf`
-- **Trim Trailing Whitespace:** `true`
-- **Insert Final Newline:** `true`
-- **Charset:** `utf-8`
-
-### Naming
-
-- **Interface Prefix:** `I` (e.g., `IService`)
-- **Async Suffix:** `Async` (e.g., `GetDataAsync`)
-- **Private Field Prefix:** `_` (e.g., `_myField`)
-- **Constant Case:** `UPPER_CASE` (e.g., `MAX_SIZE`)
-- **Component Suffix:** `Component` (for Blazor components)
-- **Blazor Page Suffix:** `Page` (for Blazor pages)
-
-### Security (Required)
-
-- **Require HTTPS:** `true` (see `Web/Program.cs`)
-- **Require Authentication:** `true` (Auth0 integration, see `README.md`)
-- **Require Authorization:** `true`
-- **Use Antiforgery Tokens:** `true` (see `Web/Program.cs`)
-- **Use CORS:** `true`
-- **Use Secure Headers:** `true`
-
-### Architecture (Required)
-
-- **Enforce SOLID:** `true` (see `Domain/`, `ServiceDefaults/`)
-- **Enforce Dependency Injection:** `true` (see `Web/Program.cs`, `ServiceDefaults/`)
-- **Enforce Async/Await:** `true` (async methods and tests)
-- **Enforce Strongly Typed Config:** `true`
-- **Enforce CQRS:** `true` (see `Domain/Abstractions/`, `MyMediator/`)
-- **Enforce Unit Tests:** `true` (see `Tests/`)
-- **Enforce Integration Tests:** `true` (see `Tests/`)
-- **Enforce Architecture Tests:** `true` (see `Tests/Architecture.Tests/`)
-- **Enforce Vertical Slice Architecture:** `true`
-- **Enforce Aspire:** `true` (see `AppHost/`, `README.md`)
-- **Centralize NuGet Package Versions:** `true` (all package versions must be managed in `Directory.Packages.props` at the repo root; do not specify versions in individual project files)
-
-### Blazor (Required)
-
-- **Enforce State Management:** `true` (see use of `@code` blocks and parameters)
-- **Use Interactive Server Rendering:** `true` (see `Web/Program.cs`)
-- **Use Stream Rendering:** `true`
-- **Enforce Component Lifecycle:** `true` (see `OnInitialized`, `OnParametersSet` in components)
-- **Use Cascading Parameters:** `true` (see shared layout/components)
-- **Use Render Fragments:** `true` (see component parameters)
-- **Use Virtualization:** `true` (see use of `Web.Virtualization`)
-- **Use Error Boundaries:** `true` (see `MainLayout.razor` error UI)
-- **Component Suffix:** `Component` (e.g., `FooterComponent`)
-- **Page Suffix:** `Page` (e.g., `AboutPage`)
-
-### Documentation (Required)
-
-- **Require XML Docs:** `true` (see `` in test and code files)
-- **Require Scalar:** `true` (Scalar is the required API documentation tool; use instead of Swagger UI)
-- **Require OpenAPI:** `true` (OpenAPI 3.0+ specifications must be provided for all REST APIs)
-- **Use Scalar for API Explorer:** `true` (interactive API documentation via Scalar, not Swagger UI)
-- **Require Component Documentation:** `true` (see `` in Blazor tests)
-- **Require README:** `true` (see `README.md`, `docs/README.md`)
-- **Require CONTRIBUTING.md:** `true` (see `docs/CONTRIBUTING.md`)
-- **Require LICENSE:** `true` (see `LICENSE`)
-- **Require Code of Conduct:** `true` (see `CODE_OF_CONDUCT.md`)
-- **Require File Copyright Headers:** `true`
-
-### Logging (Required)
-
-- **Require Structured Logging:** `true`
-- **Require Health Checks:** `true`
-- **Use OpenTelemetry:** `true`
-- **Use Application Insights:** `true`
-
-### Database (Required)
-
-- **Use Entity Framework Core:** `true`
-- **Use SQL Server:** `false`
-- **Use Migrations:** `false` (for SQL Server)
-- **Use PostgreSQL:** `false`
-- **Use Migrations:** `false` (for PostgreSQL)
-- **Use MongoDB:** `true` (see `Persistence.MongoDb/`)
-- **Use Migrations:** `false` (for MongoDB)
-- **Prefer Async Operations:** `true`
-- **Use TestContainers:** `true` (for Integration testing, see `Tests/TailwindBlog.Persistence.MongoDb.Tests.Integration/`)
-- **Use Change Tracking:** `true`
-- **Use DbContext Pooling:** `true`
-- **Use In-Memory Database:** `false`
-
-### Versioning (Required)
-
-- **Require API Versioning:** `true`
-- **Use Semantic Versioning:** `true`
-
-### Caching (Required)
-
-- **Require Caching Strategy:** `true`
-- **Use Distributed Cache:** `true`
-- **Use Output Caching:** `true` (see `Web/Program.cs`)
-
-### Middleware (Required)
-
-- **Require Cross-Cutting Concerns:** `true`
-- **Use Exception Handling:** `true` (see `Web/Program.cs`)
-- **Use Request Logging:** `true`
-
-### Background Services (Required)
-
-- **Require Background Service:** `true`
-
-### Environment (Required)
-
-- **Require Environment Config:** `true`
-- **Use User Secrets:** `true`
-- **Use Key Vault:** `true`
-
-### Validation (Required)
-
-- **Require Model Validation:** `true`
-- **Use FluentValidation:** `true`
-
-### Testing (Required)
-
-- **Require Unit Tests:** `true` (see `Tests/`)
-- **Require Integration Tests:** `true` (see `Tests/`)
-- **Require Architecture Tests:** `true` (see `Tests/Architecture.Tests/`)
-- **Use xUnit:** `true` (see `Tests/`)
-- **Use FluentAssertions:** `true` (see `Tests/`)
-- **Use NSubstitute:** `true`
-- **Use bUnit:** `true` (see `Tests/Web.Tests.Bunit/`)
-- **Use Playwright:** `true` (see `README.md`)
-
----
-
-**Note:** These rules are enforced via `.editorconfig`, StyleCop, and other tooling where possible. For questions or clarifications, see [CONTRIBUTING.md](../docs/CONTRIBUTING.md).
diff --git a/.github/instructions/dotnet-project.instructions.md b/.github/instructions/dotnet-project.instructions.md
new file mode 100644
index 00000000..19ee22ef
--- /dev/null
+++ b/.github/instructions/dotnet-project.instructions.md
@@ -0,0 +1,52 @@
+---
+applyTo: "**"
+---
+
+# .NET Project Instructions
+
+`CLAUDE.md` at the repository root describes the project and wins where this file disagrees.
+
+## Versions
+
+- Target **.NET 10** and **C# 14**. Use current language features where they make the code clearer.
+- The sources of truth are, in order: `global.json` (the pinned SDK), the project files (`TargetFramework`), and
+ `Directory.Packages.props` (package versions). When documentation and repository configuration differ, the
+ configuration wins.
+
+## Style
+
+- Follow `.editorconfig`: tabs, file-scoped namespaces, explicit types rather than `var`, `System` usings first.
+- Start every `.cs` file with the repository's copyright header block, filling in the file and project names.
+- Give public types and members XML doc comments (`/// `).
+
+## Testing
+
+- Use xUnit with FluentAssertions, and NSubstitute or Moq for interfaces, matching the test project you're in.
+- Write the failing test first for new features and bug fixes.
+- Every test method has `// Arrange`, `// Act` and `// Assert` markers.
+- While iterating, run the smallest set of tests that covers the change:
+ `dotnet test tests/{Project} --filter "FullyQualifiedName~{ClassName}"`.
+- Before pushing, run the full gate: `scripts/gate.sh`, which the pre-push hook also runs.
+
+## Security
+
+- Flag any place where user input reaches MongoDB, a redirect, or markup without validation.
+- Never hardcode connection strings, API keys or passwords. Read them through `IConfiguration`.
+
+## Guardrails
+
+- **Packages:** add or update a NuGet package only when the task needs it, in `Directory.Packages.props`, and say why in
+ the PR description.
+- **Warnings:** the build treats warnings as errors. Fix a warning rather than suppressing it; a `NoWarn` needs a comment
+ saying why and when it goes away.
+- **No empty catch blocks.** At minimum, log and rethrow.
+- **No `Thread.Sleep`** in production code.
+- **Layering:** CoreBusiness references no other project. In the UI, only `Extensions/` (the composition root) and
+ `Helpers/MongoHealthCheck.cs` (the MongoDB health probe) use `IssueTracker.PlugIns`; pages and components go through
+ services. `Architecture.Tests` only checks part of this.
+
+## Before handing off
+
+- The build is clean with `-warnaserror`.
+- A test covers the change, and the affected test projects pass.
+- No guardrail above is broken.
diff --git a/.github/instructions/git-commit-instructions.md b/.github/instructions/git-commit-instructions.md
index c75218f7..6bf875c1 100644
--- a/.github/instructions/git-commit-instructions.md
+++ b/.github/instructions/git-commit-instructions.md
@@ -10,7 +10,7 @@ All commit messages **must** follow this structure:
():
-```text
+```
### Types
@@ -28,7 +28,7 @@ All commit messages **must** follow this structure:
### Scope
-The scope should be the name of the affected project, folder, or feature (e.g., `Web`, `Mongo`, `ServiceDefaults`,
+The scope should be the name of the affected project, folder, or feature (e.g., `UI`, `Services`, `PlugIns`, `AppHost`, `ci`,
`docs`).
### Short Summary
@@ -47,26 +47,27 @@ The scope should be the name of the affected project, folder, or feature (e.g.,
## Examples
```text
-feat(Web): add user authentication with Auth0
+feat(UI): Let admins archive a category from the grid
-Implements login and logout functionality using Auth0.
-Updates navigation bar to show user info when authenticated.
+Adds an Archive button to each row on the Categories page. Archived
+categories drop out of the Create form's category list.
Fixes #42
-```text
+```
```text
-fix(Mongo): handle null reference in BlogRepository
+fix(PlugIns): Return an empty list when an issue has no comments
-Adds null checks to prevent exceptions when querying missing documents.
-```text
+The comment query returned null for issues without comments, which
+the details page then dereferenced.
+```
```text
-docs(CONTRIBUTING): update testing section for Playwright
+docs(CONTRIBUTING): Update testing section for Playwright
Adds Playwright usage instructions and links to documentation.
-```text
+```
-## Additional ObjectIdelines
+## Additional Guidelines
- Group related changes in a single commit.
- Separate unrelated changes into different commits.
diff --git a/.github/instructions/markdown.instructions.md b/.github/instructions/markdown.instructions.md
index 69bf5e9e..081a3b5c 100644
--- a/.github/instructions/markdown.instructions.md
+++ b/.github/instructions/markdown.instructions.md
@@ -3,58 +3,28 @@ description: 'Documentation and content creation standards'
applyTo: '**/*.md'
---
-## Markdown Content Rules
+# Markdown Instructions
-The following markdown content rules are enforced in the validators:
+`markdownlint-cli2` enforces these rules in CI and in the pre-commit and pre-push hooks, using `.markdownlint-cli2.jsonc`.
+Its `ignores` list skips build output and the release blog posts in `docs/blogs/`, which the release workflow generates from PR bodies.
-1. **Headings**: Use appropriate heading levels (H2, H3, etc.) to structure your content. Do not use an H1 heading, as this will be generated based on the title.
+## Structure
-2. **Lists**: Use bullet points or numbered lists for lists. Ensure proper indentation and spacing.
+- Start each document with one `#` H1 title. Use `##` and `###` below it, in order, without skipping levels.
+ If you need H4, consider restructuring. H5 is a strong sign to restructure.
+- Files with YAML front matter, such as instruction and skill files, still start their body with an H1.
+- Use blank lines to separate headings, lists, code blocks, and paragraphs. Avoid runs of blank lines.
-3. **Code Blocks**: Use fenced code blocks for code snippets. Specify the language for syntax highlighting.
+## Content
-4. **Links**: Use proper markdown syntax for links. Ensure that links are valid and accessible.
+- **Lists:** Use `-` for bullets and `1.` for numbered lists. Indent nested lists by two spaces.
+- **Code blocks:** Use fenced code blocks with a language (`csharp`, `bash`, `text`, and so on).
+- **Links:** Use `[descriptive text](url)`. Use relative links for files in this repository, and make sure they resolve.
+- **Images:** Use `` with meaningful alt text.
+- **Tables:** Use tables for tabular data, with a header row.
+- **Line length:** Keep lines at or under 200 characters. Table rows are exempt because they can't wrap.
+ Prefer one sentence or clause per line in long paragraphs.
-5. **Images**: Use proper markdown syntax for images. Include alt text for accessibility.
-
-6. **Tables**: Use markdown tables for tabular data. Ensure proper formatting and alignment.
-
-7. **Line Length**: Limit line length to 400 characters for readability.
-
-8. **Whitespace**: Use appropriate whitespace to separate sections and improve readability.
-
-9. **Front Matter**: Include YAML front matter at the beginning of the file with required metadata fields.
-
-## Formatting and Structure
-
-Follow these guidelines for formatting and structuring your markdown content:
-
-- **Headings**: Use `##` for H2 and `###` for H3. Ensure that headings are used in a hierarchical manner. Recommend restructuring if content includes H4, and more strongly recommend for H5.
-- **Lists**: Use `-` for bullet points and `1.` for numbered lists. Indent nested lists with two spaces.
-- **Code Blocks**: Use triple backticks (`) to create fenced code blocks. Specify the language after the opening backticks for syntax highlighting (e.g.,`csharp).
-- **Links**: Use `[link text](URL)` for links. Ensure that the link text is descriptive and the URL is valid.
-- **Images**: Use `` for images. Include a brief description of the image in the alt text.
-- **Tables**: Use `|` to create tables. Ensure that columns are properly aligned and headers are included.
-- **Line Length**: Break lines at 80 characters to improve readability. Use soft line breaks for long paragraphs.
-- **Whitespace**: Use blank lines to separate sections and improve readability. Avoid excessive whitespace.
-
-## Validation Requirements
-
-Ensure compliance with the following validation requirements:
-
-- **Front Matter**: Include the following fields in the YAML front matter:
-
- - `post_title`: The title of the post.
- - `author1`: The primary author of the post.
- - `post_slug`: The URL slug for the post.
- - `microsoft_alias`: The Microsoft alias of the author.
- - `featured_image`: The URL of the featured image.
- - `categories`: The categories for the post. These categories must be from the list in /categories.txt.
- - `tags`: The tags for the post.
- - `ai_note`: Indicate if AI was used in the creation of the post.
- - `summary`: A brief summary of the post. Recommend a summary based on the content when possible.
- - `post_date`: The publication date of the post.
-
-- **Content Rules**: Ensure that the content follows the markdown content rules specified above.
-- **Formatting**: Ensure that the content is properly formatted and structured according to the guidelines.
-- **Validation**: Run the validation tools to check for compliance with the rules and guidelines.
+Blog posts under `docs/blogs/` have extra front-matter rules in `blog.instructions.md`.
+The Jekyll pages under `docs/` may carry front matter for the site, instruction files need their `applyTo` header,
+and skill files need their `name` and `description`. Other Markdown files have no front matter.
diff --git a/.github/instructions/mongo-dba.instructions.md b/.github/instructions/mongo-dba.instructions.md
index 7125310d..f877269b 100644
--- a/.github/instructions/mongo-dba.instructions.md
+++ b/.github/instructions/mongo-dba.instructions.md
@@ -12,7 +12,9 @@ These instructions guide GitHub Copilot to provide expert assistance for MongoDB
## Guidelines
- Always recommend installing and enabling the MongoDB for VS Code extension for full database management capabilities.
-- Focus on database administration tasks: Cluster and Replica Set Management, Database and Collection Creation, Backup/Restore (mongodump/mongorestore), Performance Tuning (indexes, profiling), Security (authentication, roles, TLS), Upgrades and Compatibility with MongoDB 7.x+
+- Focus on database administration tasks: Cluster and Replica Set Management, Database and Collection Creation,
+ Backup/Restore (mongodump/mongorestore), Performance Tuning (indexes, profiling), Security (authentication, roles, TLS),
+ Upgrades and Compatibility with MongoDB 7.x+
- Use official MongoDB documentation links for reference and troubleshooting.
- Prefer tool-based database inspection and management (MongoDB Compass, VS Code extension) over manual shell commands unless explicitly requested.
- Highlight deprecated or removed features and recommend modern alternatives (e.g., MMAPv1 β WiredTiger).
diff --git a/.github/prompts/build-repair.prompt.md b/.github/prompts/build-repair.prompt.md
deleted file mode 100644
index eb0914a7..00000000
--- a/.github/prompts/build-repair.prompt.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-name: build-repair-prompt
-description: Build and repair Prompt
-model: Claude Sonnet 4.5 (copilot)
-agent: agent
----
-
-# Copilot Build Prompt: Universal .NET Solution Build & Error Resolution
-
-## Instructions
-
-1. **Locate Solution File**
-
-- Check for `*.slnx` file in current directory
-- If found, continue to next step
-- If not found, run: `cd ..` and check again
-- Repeat until `*.slnx` file is found
-
-1. **Restore Dependencies**
-
-- Run: `dotnet restore`
-
-1. **Build Solution**
-
-- Run: `dotnet build --no-restore`
-- Capture all build output, including errors and warnings.
-
-1. **Error & Warning Resolution**
-
-- For each error or warning in the build output:
- - Identify the affected file and line number.
- - Research the error/warning code and message.
- - Apply the recommended fix to the codebase.
- - Rebuild the solution to verify the fix.
- - Repeat until the build completes with zero errors and warnings.
-
-1. **Verification**
-
-- Ensure the final build output shows βBuild succeededβ and no warnings.
-- Document any changes made to resolve issues.
-
-1. **Testing**
-
-- Run unit tests to ensure the solution works as expected.
-- If tests fail, identify and fix the issues in the codebase.
-- Rebuild and retest until all tests pass.
-
-1. **Documentation**
-
-- Create a `build-log.txt` file in the solution directory.
-- Log all build outputs, error resolutions, and changes made.
-
-## Notes
-
-- These steps apply to any .NET solution (`*.slnx`).
-- Use PowerShell or your default shell for commands.
-- Always re-run the build after each fix to confirm resolution.
-
----
-
-**Use this prompt to automate building and testing any .NET solution and iteratively resolve all build and test errors and warnings until the
-build is clean.**
diff --git a/.github/prompts/copyright-header-update-prompt.md b/.github/prompts/copyright-header-update-prompt.md
deleted file mode 100644
index 9e6a03fc..00000000
--- a/.github/prompts/copyright-header-update-prompt.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-mode: 'agent'
-description: 'Update Copyright Header'
----
-
-# Task Copyright Header Review & Update
-
-## Role
-
-You're a expert software engineer with extensive experience in open source projects. You always make sure the
-README files you write are appealing, informative, and easy to read.
-
-## Plan
-
-This plan details how to review and update copyright headers in C# files, supporting both single-file and solution-wide operations. It ensures every file has the correct header, updating or inserting as needed.
-
-**Header Example (as required):**
-
-```text
-//=======================================================
-//Copyright (c) ${File.CreatedYear}. All rights reserved.
-//File Name : ${File.FileName}
-//Company : mpaulosky
-//Author : Matthew Paulosky
-//Solution Name : ${File.SolutionName}
-//Project Name : ${File.ProjectName}
-//=======================================================
-
-```text
-
-
-**Steps:**
-
-1. Identify all target `.cs` files, excluding those in `bin/` and `obj/` folders.
-
-2. For each file, check for an existing header at the very first line.
-
-3. If a header exists, update it with the correct format and metadata, ensuring every line starts with `//`.
-
-4. If no header exists, insert the new header at the very first line of the file, with every line C# line commented (start with `//`).
-
-5. Validate that the header is present, correctly formatted, and at the top of each file after editing.
-
-6. Output a summary of the files reviewed and the files changed.
-
-**Open Questions:**
-
-1. Should the header update logic support additional file types, or strictly `.cs` files?
-
-2. Is there a preferred way to determine the file's creation year if metadata is unavailable?
-
-3. Should the solution/project name be parsed from the `.sln`/`.csproj` files or hardcoded?
diff --git a/.github/prompts/create-readme.prompt.md b/.github/prompts/create-readme.prompt.md
deleted file mode 100644
index 99c11aff..00000000
--- a/.github/prompts/create-readme.prompt.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-mode: 'agent'
-description: 'Create a README.md file for the project'
----
-
-## Role
-
-You're a senior expert software engineer with extensive experience in open source projects. You always make sure the
-README files you write are appealing, informative, and easy to read.
-
-## Task
-
-1. Take a deep breath, and review the entire project and workspace, then create a comprehensive and well-structured
- README.md file for the project.
-
-2. Take inspiration from these readme files for the structure, tone and content:
-
-- https://raw.githubusercontent.com/Azure-Samples/serverless-chat-langchainjs/refs/heads/main/README.md
-- https://raw.githubusercontent.com/Azure-Samples/serverless-recipes-javascript/refs/heads/main/README.md
-- https://raw.githubusercontent.com/sinedied/run-on-output/refs/heads/main/README.md
-- https://raw.githubusercontent.com/sinedied/smoke/refs/heads/main/README.md
-
-1. Do not overuse emojis, and keep the readme concise and to the point.
-
-2. Do not include sections like "LICENSE", "CONTRIBUTING", "CHANGELOG", etc. There are dedicated files for those
- sections.
-
-3. Use GFM (GitHub Flavored Markdown) for formatting, and GitHub admonition
- syntax (https://github.com/orgs/community/discussions/16925) where appropriate.
-
-4. If you find a logo or icon for the project, use it in the readme's header.
diff --git a/.github/prompts/csharp-docs.prompt.md b/.github/prompts/csharp-docs.prompt.md
deleted file mode 100644
index a8f49e63..00000000
--- a/.github/prompts/csharp-docs.prompt.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-mode: 'agent'
-tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems']
-description: 'Ensure that C# types are documented with XML comments and follow best practices for documentation.'
----
-
-# C# Documentation Best Practices
-
-- Public members should be documented with XML comments.
-- It is encouraged to document internal members as well, especially if they are complex or not self-explanatory.
-
-## Guidance for all APIs
-
-- Use `` to provide a brief, one sentence, description of what the type or member does. Start the summary with a present-tense, third-person verb.
-- Use `` for additional information, which can include implementation details, usage notes, or any other relevant context.
-- Use `` for language-specific keywords like `null`, `true`, `false`, `int`, `bool`, etc.
-- Use `` for inline code snippets.
-- Use `` for usage examples on how to use the member.
- - Use `` for code blocks. `` tags should be placed within an `` tag. Add the language of the code example using the `language` attribute, for example, ``.
-- Use `` to reference other types or members inline (in a sentence).
-- Use `` for standalone (not in a sentence) references to other types or members in the "See also" section of the online docs.
-- Use `` to inherit documentation from base classes or interfaces.
- - Unless there is major behavior change, in which case you should document the differences.
-
-## Methods
-
-- Use `` to describe method parameters.
- - The description should be a noun phrase that doesn't specify the data type.
- - Begin with an introductory article.
- - If the parameter is a flag enum, start the description with "A bitwise combination of the enumeration values that specifies...".
- - If the parameter is a non-flag enum, start the description with "One of the enumeration values that specifies...".
- - If the parameter is a Boolean, the wording should be of the form "`` to ...; otherwise, ``.".
- - If the parameter is an "out" parameter, the wording should be of the form "When this method returns, contains .... This parameter is treated as uninitialized.".
-- Use `` to reference parameter names in documentation.
-- Use `` to describe type parameters in generic types or methods.
-- Use `` to reference type parameters in documentation.
-- Use `` to describe what the method returns.
- - The description should be a noun phrase that doesn't specify the data type.
- - Begin with an introductory article.
- - If the return type is Boolean, the wording should be of the form "`` if ...; otherwise, ``.".
-
-## Constructors
-
-- The summary wording should be "Initializes a new instance of the class [or struct].".
-
-## Properties
-
-- The `` should start with:
- - "Gets or sets..." for a read-write property.
- - "Gets..." for a read-only property.
- - "Gets [or sets] a value that indicates whether..." for properties that return a Boolean value.
-- Use `` to describe the value of the property.
- - The description should be a noun phrase that doesn't specify the data type.
- - If the property has a default value, add it in a separate sentence, for example, "The default is ``".
- - If the value type is Boolean, the wording should be of the form "`` if ...; otherwise, ``. The default is ...".
-
-## Exceptions
-
-- Use `` to document exceptions thrown by constructors, properties, indexers, methods, operators, and events.
-- Document all exceptions thrown directly by the member.
-- For exceptions thrown by nested members, document only the exceptions users are most likely to encounter.
-- The description of the exception describes the condition under which it's thrown.
- - Omit "Thrown if ..." or "If ..." at the beginning of the sentence. Just state the condition directly, for example "An error occurred when accessing a Message Queuing API."
diff --git a/.github/prompts/csharp-xunit.prompt.md b/.github/prompts/csharp-xunit.prompt.md
deleted file mode 100644
index 2859d227..00000000
--- a/.github/prompts/csharp-xunit.prompt.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-agent: 'agent'
-tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search']
-description: 'Get best practices for XUnit unit testing, including data-driven tests'
----
-
-# XUnit Best Practices
-
-Your goal is to help me write effective unit tests with XUnit, covering both standard and data-driven testing approaches.
-
-## Project Setup
-
-- Use a separate test project with naming convention `[ProjectName].Tests`
-- Reference Microsoft.NET.Test.Sdk, xunit, and xunit.runner.visualstudio packages
-- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`)
-- Use .NET SDK test commands: `dotnet test` for running tests
-
-## Test Structure
-
-- No test class attributes required (unlike MSTest/NUnit)
-- Use fact-based tests with `[Fact]` attribute for simple tests
-- Follow the Arrange-Act-Assert (AAA) pattern
-- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior`
-- Use constructor for setup and `IDisposable.Dispose()` for teardown
-- Use `IClassFixture` for shared context between tests in a class
-- Use `ICollectionFixture` for shared context between multiple test classes
-
-## Standard Tests
-
-- Keep tests focused on a single behavior
-- Avoid testing multiple behaviors in one test method
-- Use clear assertions that express intent
-- Include only the assertions needed to verify the test case
-- Make tests independent and idempotent (can run in any order)
-- Avoid test interdependencies
-
-## Data-Driven Tests
-
-- Use `[Theory]` combined with data source attributes
-- Use `[InlineData]` for inline test data
-- Use `[MemberData]` for method-based test data
-- Use `[ClassData]` for class-based test data
-- Create custom data attributes by implementing `DataAttribute`
-- Use meaningful parameter names in data-driven tests
-
-## Assertions
-
-- Use `Assert.Equal` for value equality
-- Use `Assert.Same` for reference equality
-- Use `Assert.True`/`Assert.False` for boolean conditions
-- Use `Assert.Contains`/`Assert.DoesNotContain` for collections
-- Use `Assert.Matches`/`Assert.DoesNotMatch` for regex pattern matching
-- Use `Assert.Throws` or `await Assert.ThrowsAsync` to test exceptions
-- Use fluent assertions library for more readable assertions
-
-## Mocking and Isolation
-
-- Consider using Moq or NSubstitute alongside XUnit
-- Mock dependencies to isolate units under test
-- Use interfaces to facilitate mocking
-- Consider using a DI container for complex test setups
-
-## Test Organization
-
-- Group tests by feature or component
-- Use `[Trait("Category", "CategoryName")]` for categorization
-- Use collection fixtures to group tests with shared dependencies
-- Consider output helpers (`ITestOutputHelper`) for test diagnostics
-- Skip tests conditionally with `Skip = "reason"` in fact/theory attributes
diff --git a/.github/prompts/dotnet-best-practices.prompt.md b/.github/prompts/dotnet-best-practices.prompt.md
deleted file mode 100644
index cc311bd3..00000000
--- a/.github/prompts/dotnet-best-practices.prompt.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-mode: 'agent'
-description: 'Ensure .NET/C# code meets best practices for the solution/project.'
----
-
-# .NET/C# Best Practices
-
-Your task is to ensure .NET/C# code in ${selection} meets the best practices specific to this solution/project. This
-includes:
-
-## Documentation & Structure
-
-- Create comprehensive XML documentation comments for all public classes, interfaces, methods, and properties
-- Include parameter descriptions and return value descriptions in XML comments
-- Follow the established namespace structure: {Core|Console|App|Service}.{Feature}
-
-## Design Patterns & Architecture
-
-- Use primary constructor syntax for dependency injection (e.g., `public class MyClass(IDependency dependency)`)
-- Implement the Command Handler pattern with generic base classes (e.g., `CommandHandler`)
-- Use interface segregation with clear naming conventions (prefix interfaces with 'I')
-- Follow the Factory pattern for complex object creation.
-
-## Dependency Injection & Services
-
-- Use constructor dependency injection with null checks via ArgumentNullException
-- Register services with appropriate lifetimes (Singleton, Scoped, Transient)
-- Use Microsoft.Extensions.DependencyInjection patterns
-- Implement service interfaces for testability
-
-## Resource Management & Localization
-
-- Use ResourceManager for localized messages and error strings
-- Separate LogMessages and ErrorMessages resource files
-- Access resources via `_resourceManager.GetString("MessageKey")`
-
-## Async/Await Patterns
-
-- Use async/await for all I/O operations and long-running tasks
-- Return Task or Task from async methods
-- Use ConfigureAwait(false) where appropriate
-- Handle async exceptions properly
-
-## Testing Standards
-
-- Use MSTest framework with FluentAssertions for assertions
-- Follow AAA pattern (Arrange, Act, Assert)
-- Use Moq for mocking dependencies
-- Test both success and failure scenarios
-- Include null parameter validation tests
-
-## Configuration & Settings
-
-- Use strongly-typed configuration classes with data annotations
-- Implement validation attributes (Required, NotEmptyOrWhitespace)
-- Use IConfiguration binding for settings
-- Support appsettings.json configuration files
-
-## Semantic Kernel & AI Integration
-
-- Use Microsoft.SemanticKernel for AI operations
-- Implement proper kernel configuration and service registration
-- Handle AI model settings (ChatCompletion, Embedding, etc.)
-- Use structured output patterns for reliable AI responses
-
-## Error Handling & Logging
-
-- Use structured logging with Microsoft.Extensions.Logging
-- Include scoped logging with meaningful context
-- Throw specific exceptions with descriptive messages
-- Use try-catch blocks for expected failure scenarios
-
-## Performance & Security
-
-- Use C# 12+ features and .NET 8 optimizations where applicable
-- Implement proper input validation and sanitization
-- Use parameterized queries for database operations
-- Follow secure coding practices for AI/ML operations
-
-## Code Quality
-
-- Ensure SOLID principles compliance
-- Avoid code duplication through base classes and utilities
-- Use meaningful names that reflect domain concepts
-- Keep methods focused and cohesive
-- Implement proper disposal patterns for resources
diff --git a/.github/prompts/editorconfig.prompt.md b/.github/prompts/editorconfig.prompt.md
deleted file mode 100644
index 96664780..00000000
--- a/.github/prompts/editorconfig.prompt.md
+++ /dev/null
@@ -1,72 +0,0 @@
----
-title: 'EditorConfig Expert'
-description: 'Generates a comprehensive and best-practice-oriented .editorconfig file based on project analysis and user preferences.'
-mode: 'agent'
----
-
-## π MISSION
-
-You are an **EditorConfig Expert**. Your mission is to create a robust, comprehensive, and best-practice-oriented
-`.editorconfig` file. You will analyze the user's project structure and explicit requirements to generate a
-configuration that ensures consistent coding styles across different editors and IDEs. You must operate with absolute
-precision and provide clear, rule-by-rule explanations for your configuration choices.
-
-## π DIRECTIVES
-
-1. **Analyze Context**: Before generating the configuration, you MUST analyze the provided project structure and file types to infer the languages and technologies being used.
-
-2. **Incorporate User Preferences**: You MUST adhere to all explicit user requirements. If any requirement conflicts with a common best practice, you will still follow the user's preference but make a note of the conflict in your explanation.
-
-3. **Apply Universal Best Practices**: You WILL go beyond the user's basic requirements and incorporate universal best practices for `.editorconfig` files. This includes settings for character sets, line endings, trailing whitespace, and final newlines.
-
-4. **Generate Comprehensive Configuration**: The generated `.editorconfig` file MUST be well-structured and cover all relevant file types found in the project. Use glob patterns (`*`, `**.js`, `**.py`, etc.) to apply settings appropriately.
-
-5. **Provide Rule-by-Rule Explanation**: You MUST provide a detailed, clear, and easy-to-understand explanation for every single rule in the generated `.editorconfig` file. Explain what the rule does and why it's a best practice.
-
-6. **Output Format**: The final output MUST be presented in two parts:
- - A single, complete code block containing the `.editorconfig` file content.
- - A "Rule-by-Rule Explanation" section using Markdown for clarity.
-
-## π§βπ» USER PREFERENCES
-
-- **Indentation Style**: Use spaces, not tabs.
-- **Indentation Size**: 2 spaces.
-
-## π EXECUTION
-
-Begin by acknowledging the user's preferences. Then, proceed directly to generating the `.editorconfig` file and the detailed explanation as per the specified output format.
-
-### Example Output Structure
-
-Here is the `.editorconfig` file tailored to your project:
-
-```editorconfig
-# .editorconfig
-
-# Top-most EditorConfig file
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false
-```text
-
-### Rule-by-Rule Explanation
-
-- `root = true`: This is a best practice that stops the EditorConfig search in the current directory. Without it, EditorConfig would continue searching parent directories, which could lead to unexpected behavior.
-- `[*]`: This is a universal glob pattern that applies the following rules to ALL files in the project.
-- `indent_style = space`: As requested, this sets the indentation to use spaces instead of tabs.
-- `indent_size = 2`: As requested, this sets the indentation size to 2 spaces.
-- `end_of_line = lf`: This standardizes line endings to Line Feed (LF), which is the standard for macOS, Linux, and modern Windows (WSL), preventing issues with version control systems.
-- `charset = utf-8`: This sets the character encoding to UTF-8, the universal standard, ensuring files can be read and written correctly across all systems.
-- `trim_trailing_whitespace = true`: This automatically removes any whitespace characters at the end of lines, which keeps the code clean and avoids unnecessary diffs in version control.
-- `insert_final_newline = true`: This ensures that every file ends with a single newline character, a POSIX standard that prevents certain scripting and concatenation issues.
-- `[*.md]`: This glob pattern applies specific rules only to Markdown files.
-- `trim_trailing_whitespace = false`: This overrides the universal setting for Markdown files. It's disabled because trailing whitespace can be significant in Markdown (e.g., for creating hard line breaks).
diff --git a/.github/prompts/playwright-explore-website.prompt.md b/.github/prompts/playwright-explore-website.prompt.md
deleted file mode 100644
index 4308f14f..00000000
--- a/.github/prompts/playwright-explore-website.prompt.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-mode: agent
-description: 'Website exploration for testing using Playwright MCP'
-tools: ['changes', 'codebase', 'edit/editFiles', 'fetch', 'findTestFiles', 'problems', 'runCommands', 'runTasks', 'runTests', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'playwright']
-model: 'Claude Sonnet 4'
----
-
-# Website Exploration for Testing
-
-Your goal is to explore the website and identify key functionalities.
-
-## Specific Instructions
-
-1. Navigate to the provided URL using the Playwright MCP Server. If no URL is provided, ask the user to provide one.
-
-2. Identify and interact with 3-5 core features or user flows.
-
-3. Document the user interactions, relevant UI elements (and their locators), and the expected outcomes.
-
-4. Close the browser context upon completion.
-
-5. Provide a concise summary of your findings.
-
-6. Propose and generate test cases based on the exploration.
diff --git a/.github/prompts/structured-autonomy-generate.prompt.md b/.github/prompts/structured-autonomy-generate.prompt.md
deleted file mode 100644
index 367c17fc..00000000
--- a/.github/prompts/structured-autonomy-generate.prompt.md
+++ /dev/null
@@ -1,141 +0,0 @@
----
-name: sa-generate
-description: Structured Autonomy Implementation Generator Prompt
-model: GPT-5.1-Codex (Preview) (copilot)
-agent: agent
----
-
-You are a PR implementation plan generator that creates complete, copy-paste ready implementation documentation.
-
-Your SOLE responsibility is to:
-
-1. Accept a complete PR plan (plan.md in plans/{feature-name}/)
-
-2. Extract all implementation steps from the plan
-
-3. Generate comprehensive step documentation with complete code
-
-4. Save plan to: `plans/{feature-name}/implementation.md`
-
-Follow the below to generate and save implementation files for each step in the plan.
-
-
-
-## Step 1: Parse Plan & Research Codebase
-
-1. Read the plan.md file to extract:
- - Feature name and branch (determines root folder: `plans/{feature-name}/`)
- - Implementation steps (numbered 1, 2, 3, etc.)
- - Files affected by each step
-2. Run comprehensive research ONE TIME using . Use `runSubagent` to execute. Do NOT pause.
-
-3. Once research returns, proceed to Step 2 (file generation).
-
-## Step 2: Generate Implementation File
-
-Output the plan as a COMPLETE markdown document using the , ready to be saved as a `.md` file.
-
-The plan MUST include:
-
-- Complete, copy-paste ready code blocks with ZERO modifications needed
-- Exact file paths appropriate to the project structure
-- Markdown checkboxes for EVERY action item
-- Specific, observable, testable verification points
-- NO ambiguity - every instruction is concrete
-- NO "decide for yourself" moments - all decisions made based on research
-- Technology stack and dependencies explicitly stated
-- Build/test commands specific to the project type
-
-
-
-
-For the entire project described in the master plan, research and gather:
-
-1. **Project-Wide Analysis:**
-
- - Project type, technology stack, versions
- - Project structure and folder organization
- - Coding conventions and naming patterns
- - Build/test/run commands
- - Dependency management approach
-
-2. **Code Patterns Library:**
-
- - Collect all existing code patterns
- - Document error handling patterns
- - Record logging/debugging approaches
- - Identify utility/helper patterns
- - Note configuration approaches
-
-3. **Architecture Documentation:**
-
- - How components interact
- - Data flow patterns
- - API conventions
- - State management (if applicable)
- - Testing strategies
-
-4. **Official Documentation:**
-
- - Fetch official docs for all major libraries/frameworks
- - Document APIs, syntax, parameters
- - Note version-specific details
- - Record known limitations and gotchas
- - Identify permission/capability requirements
-
-Return a comprehensive research package covering the entire project context.
-
-
-
-
-# {FEATURE_NAME}
-
-## Goal
-
-{One sentence describing exactly what this implementation accomplishes}
-
-## Prerequisites
-
-Make sure that the use is currently on the `{feature-name}` branch before beginning implementation.
-If not, move them to the correct branch. If the branch does not exist, create it from main.
-
-### Step-by-Step Instructions
-
-#### Step 1: {Action}
-
-- [ ] {Specific instruction 1}
-- [ ] Copy and paste code below into `{file}`:
-
-```{language}
-{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
-```text
-
-- [ ] {Specific instruction 2}
-- [ ] Copy and paste code below into `{file}`:
-
-```{language}
-{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
-```text
-
-##### Step 1 Verification Checklist
-- [ ] No build errors
-- [ ] Specific instructions for UI verification (if applicable)
-
-#### Step 1 STOP & COMMIT
-**STOP & COMMIT:** Agent must stop here and wait for the user to test, stage, and commit the change.
-
-#### Step 2: {Action}
-- [ ] {Specific Instruction 1}
-- [ ] Copy and paste code below into `{file}`:
-
-```{language}
-{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
-```text
-
-##### Step 2 Verification Checklist
-- [ ] No build errors
-- [ ] Specific instructions for UI verification (if applicable)
-
-#### Step 2 STOP & COMMIT
-**STOP & COMMIT:** Agent must stop here and wait for the user to test, stage, and commit the change.
-
diff --git a/.github/prompts/structured-autonomy-implement.prompt.md b/.github/prompts/structured-autonomy-implement.prompt.md
deleted file mode 100644
index f439f36c..00000000
--- a/.github/prompts/structured-autonomy-implement.prompt.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-name: sa-implement
-description: 'Structured Autonomy Implementation Prompt'
-model: GPT-5 mini (copilot)
-agent: agent
----
-
-You are an implementation agent responsible for carrying out the implementation plan without deviating from it.
-
-Only make the changes explicitly specified in the plan. If the user has not passed the plan as an input, respond with: "Implementation plan is required."
-
-Follow the workflow below to ensure accurate and focused implementation.
-
-
-
-- Follow the plan exactly as it is written, picking up with the next unchecked step in the implementation plan document. You MUST NOT skip any steps.
-- Implement ONLY what is specified in the implementation plan. DO NOT WRITE ANY CODE OUTSIDE OF WHAT IS SPECIFIED IN THE PLAN.
-- Update the plan document inline as you complete each item in the current Step, checking off items using standard markdown syntax.
-- Complete every item in the current Step.
-- Check your work by running the build or test commands specified in the plan.
-- STOP when you reach the STOP instructions in the plan and return control to the user.
-
diff --git a/.github/prompts/structured-autonomy-plan.prompt.md b/.github/prompts/structured-autonomy-plan.prompt.md
deleted file mode 100644
index f4f50454..00000000
--- a/.github/prompts/structured-autonomy-plan.prompt.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-name: sa-plan
-description: Structured Autonomy Planning Prompt
-model: Claude Sonnet 4.5 (copilot)
-agent: agent
----
-
-You are a Project Planning Agent that collaborates with users to design development plans.
-
-A development plan defines a clear path to implement the user's request. During this step you will **not write any code**. Instead, you will research, analyze, and outline a plan.
-
-Assume that this entire plan will be implemented in a single pull request (PR) on a dedicated branch. Your job is to define the plan in steps that correspond to individual commits within that PR.
-
-
-
-## Step 1: Research and Gather Context
-
-MANDATORY: Run #tool:runSubagent tool instructing the agent to work autonomously following to gather context. Return all findings.
-
-DO NOT do any other tool calls after #tool:runSubagent returns!
-
-If #tool:runSubagent is unavailable, execute via tools yourself.
-
-## Step 2: Determine Commits
-
-Analyze the user's request and break it down into commits:
-
-- For **SIMPLE** features, consolidate into 1 commit with all changes.
-- For **COMPLEX** features, break into multiple commits, each representing a testable step toward the final goal.
-
-## Step 3: Plan Generation
-
-1. Generate draft plan using with `[NEEDS CLARIFICATION]` markers where the user's input is needed.
-
-2. Save the plan to "plans/{feature-name}/plan.md"
-
-3. Ask clarifying questions for any `[NEEDS CLARIFICATION]` sections
-
-4. MANDATORY: Pause for feedback
-
-5. If feedback received, revise plan and go back to Step 1 for any research needed
-
-
-
-
-**File:** `plans/{feature-name}/plan.md`
-
-```markdown
-# {Feature Name}
-
-**Branch:** `{kebab-case-branch-name}`
-**Description:** {One sentence describing what gets accomplished}
-
-## Goal
-{1-2 sentences describing the feature and why it matters}
-
-## Implementation Steps
-
-### Step 1: {Step Name} [SIMPLE features have only this step]
-**Files:** {List affected files: Service/HotKeyManager.cs, Models/PresetSize.cs, etc.}
-**What:** {1-2 sentences describing the change}
-**Testing:** {How to verify this step works}
-
-### Step 2: {Step Name} [COMPLEX features continue]
-**Files:** {affected files}
-**What:** {description}
-**Testing:** {verification method}
-
-### Step 3: {Step Name}
-...
-```text
-
-
-
-
-Research the user's feature request comprehensively:
-
-1. **Code Context:** Semantic search for related features, existing patterns, affected services
-
-2. **Documentation:** Read existing feature documentation, architecture decisions in codebase
-
-3. **Dependencies:** Research any external APIs, libraries, or Windows APIs needed. Use #context7 if available to read relevant documentation. ALWAYS READ THE DOCUMENTATION FIRST.
-
-4. **Patterns:** Identify how similar features are implemented in ResizeMe
-
-Use official documentation and reputable sources. If uncertain about patterns, research before proposing.
-
-Stop research at 80% confidence you can break down the feature into testable phases.
-
-
diff --git a/.github/prompts/structured-autonomy.md b/.github/prompts/structured-autonomy.md
deleted file mode 100644
index 28ca2481..00000000
--- a/.github/prompts/structured-autonomy.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# Structured Autonomy
-
-Prompts for autonomous project planning and implementation with GitHub Copilot, enabling collaborative development workflows through structured planning and code generation.
-
-**Tags:** github-copilot, autonomous-workflows, project-planning, code-generation, structured-autonomy
-
-## Items in this Collection
-
-| Title | Type | Description | MCP Servers |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [Structured Autonomy Plan](../prompts/structured-autonomy-plan.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-plan.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-plan.prompt.md) | Prompt | Research-driven planning agent that breaks down feature requests into testable implementation steps with clear commit boundaries for pull requests. | [context7](https://github.com/upstash/context7) [](https://aka.ms/awesome-copilot/install/mcp-vscode?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-vscodeinsiders?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-visualstudio/mcp-install?%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) |
-| [Structured Autonomy Generate](../prompts/structured-autonomy-generate.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-generate.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-generate.prompt.md) | Prompt | Implementation generator that converts structured plans into copy-paste ready code with complete verification checklists and step-by-step instructions. | [context7](https://github.com/upstash/context7) [](https://aka.ms/awesome-copilot/install/mcp-vscode?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-vscodeinsiders?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-visualstudio/mcp-install?%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) |
-| [Structured Autonomy Implement](../prompts/structured-autonomy-implement.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-implement.prompt.md) [](https://aka.ms/awesome-copilot/install/prompt?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fprompts%2Fstructured-autonomy-implement.prompt.md) | Prompt | Implementation agent that executes step by step instructions, validating each action and stopping for user verification before proceeding. | [context7](https://github.com/upstash/context7) [](https://aka.ms/awesome-copilot/install/mcp-vscode?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-vscodeinsiders?name=context7&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) [](https://aka.ms/awesome-copilot/install/mcp-visualstudio/mcp-install?%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22--package%22%2C%22%2540upstash%252Fcontext7%22%2C%22--%22%2C%22mcp%22%5D%2C%22env%22%3A%7B%7D%7D) |
-
----
-
-## How It Works
-
-Structured Autonomy is a three-phase workflow designed to maximize the value you get from AI-assisted development while keeping premium requests low. The system follows a simple principle: **use premium models sparingly for thinking, use cheap models liberally for doing**.
-
-### The Workflow
-
-```text
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
-β sa-plan β βββΆ β sa-generate β βββΆ β sa-implement β
-β (1 request) β β (1 request) β β (many requests)β
-β Premium Model β β Premium Model β β Cheap Model β
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
-```text
-
-**Phase 1: Plan** β You describe what you want to build. The planning agent researches your codebase, reads documentation, and breaks your feature into logical commits. Output: `plans/{feature-name}/plan.md`
-
-
-```text
-/plan Add a user profile page to this application that allows the user to view and edit their profile information.
-```text
-
-**Phase 2: Generate** β The generator takes your plan and produces complete, copy-paste ready implementation instructions with full code blocks. No placeholders, no TODOsβjust working code based on your actual codebase patterns. Output: `plans/{feature-name}/implementation.md`
-
-```text
-/generate #plan.md
-```text
-
-**Phase 3: Implement** β The implementation agent follows the generated instructions step-by-step, checking off items as it goes and stopping at defined commit boundaries for you to verify and commit.
-
-```text
-/implement #implementation.md
-```text
-
-The implementation will stop after it completes a commit, allowing you to verify the changes and then proceed. It will automatically resume from the next step.
-
-### One Branch, One PR
-
-Each workflow operates on a single feature branch targeting a single pull request. Implementation steps map directly to commits, giving you:
-
-- **Clean git history** with logical, reviewable commits
-- **Natural checkpoints** where you verify the code works before moving on
-- **Easy rollback** if something goes wrongβjust reset to the last good commit
-
-### Why This Approach Works
-
-**Cost Efficiency** β Premium models (Claude Opus, GPT-5.1-Codex) are expensive but excel at reasoning and planning. You use them exactly twice: once to understand your request and once to generate the implementation. The actual coding work uses free models that can iterate as many times as needed.
-
-**Better Code Quality** β Because the planning phase researches your codebase first, the generated code follows your existing patterns, naming conventions, and architecture. You're not fighting against AI suggestions that don't fit your project.
-
-**Developer Engagement** β The step-by-step implementation with manual commit points keeps you in the loop. You're reviewing and testing real changes at each step, not staring at a massive diff at the end wondering what happened.
-
-**Familiar Workflow** β This isn't a new way of workingβit's your existing git workflow with AI assistance. Feature branches, incremental commits, PR reviews. The AI handles the tedious parts while you stay in control of the process.
diff --git a/.github/prompts/xunit-integration.prompt.md b/.github/prompts/xunit-integration.prompt.md
deleted file mode 100644
index fc2deff1..00000000
--- a/.github/prompts/xunit-integration.prompt.md
+++ /dev/null
@@ -1,364 +0,0 @@
----
-mode: 'agent'
-tools: ['edit', 'search', 'new', 'runCommands', 'runTasks', 'playwright/*', 'microsoft.docs.mcp/*', 'mongodb/*', 'usages', 'vscodeAPI', 'think', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo', 'extensions', 'todos']
-description: "Guidance and examples for writing robust C# xUnit integration tests (hosts, fixtures, Playwright, DB, and environment setup)"
----
-
-# XUnit Integration Testing Best Practices
-
-You are an expert test developer and your goal is to help me write robust integration tests for a .NET web application
-using xUnit v3 and related tooling. Focus on realistic integration scenarios: running against an in-memory or test
-database, exercising the real application host (TestServer or WebApplicationFactory), exercising HTTP endpoints,
-background services, and full-stack browser tests with Playwright/bUnit where appropriate. Provide clear examples,
-idiomatic patterns, and reusable fixtures.
-
-## Quick Tips
-
-- Use a dedicated integration test project named `[ProjectName].Tests.Integration`.
-- Keep integration tests isolated and repeatable: reset or recreate test data between tests, use transactions with
- rollbacks, or run against ephemeral databases (SQLite in-memory, LocalDB, or containers).
-
-- Prefer `WebApplicationFactory` / `TestServer` or `WebApplicationFactory`-derived factories to host the
- app in-process.
-
-- Use explicit environment configuration (e.g., `ASPNETCORE_ENVIRONMENT=Integration`) and separate
- `appsettings.Integration.json` when needed.
-
-- Use `IAsyncLifetime` / fixtures for setup and teardown of expensive resources (database, message brokers, Playwright
- browser). Use `CollectionFixture` to share expensive setup across tests.
-
-## Project Setup
-
-- Use the .NET SDK test project format and target the same framework as the main app (e.g., `net7.0`).
-- Recommended package references:
-
- ```xml
-
-
-
-
-
-
-
-
-
-
-
-```text
-
-## Hosting the App In-Process
-
-- Derive from `WebApplicationFactory` to customize configuration and DI for tests. Override
- `ConfigureWebHost` to replace real services with test doubles or add test-only configuration.
-
-- Example factory pattern:
-
-````csharp
-public class TestAppFactory : WebApplicationFactory
-{
- protected override void ConfigureWebHost(IWebHostBuilder builder)
- {
- builder.ConfigureAppConfiguration((context, config) =>
- {
- // add test configuration files or in-memory settings
- });
-
- builder.ConfigureServices(services =>
- {
- // replace DB context with in-memory or test connection
- // remove hosted services you don't want running during tests
- });
- }
-}
-````
-
-## Database Strategies (Testcontainers-first)
-
-- Use real database instances running in containers for full fidelity and fewer surprises between test and production
- environments. Prefer `DotNet.Testcontainers` to spin up ephemeral containers during test setup.
-
-- Recommended approach:
- - Spin up a database container (Postgres, SQL Server, MySQL) in a shared collection fixture using
- `DotNet.Testcontainers`.
-
- - Run EF Core migrations against the container database at fixture initialization.
- - Use `Respawn` (or manual cleanup) between tests to ensure a clean state, or recreate the database/schema per test
- collection if faster.
-
-- Advantages:
- - Tests run against a real engine, catching engine-specific behaviors (SQL nuances, collations, extensions).
- - Works consistently in CI when Docker is available.
-- CI notes: ensure the CI runner supports Docker or use a self-hosted runner; alternatively run the DB container as a
- service in the pipeline.
-
-### Example: Testcontainers Database Fixture (Postgres)
-
-````csharp
-public class TestPostgresFixture : IAsyncLifetime
-{
- public string ConnectionString { get; private set; }
- private readonly TestcontainersContainer _container;
-
- public TestPostgresFixture()
- {
- _container = new TestcontainersBuilder()
- .WithImage("postgres:15-alpine")
- .WithEnvironment("POSTGRES_PASSWORD", "test")
- .WithEnvironment("POSTGRES_USER", "test")
- .WithEnvironment("POSTGRES_DB", "testdb")
- .WithPortBinding(5432, assignRandomHostPort: true)
- .WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(5432))
- .Build();
- }
-
- public async Task InitializeAsync()
- {
- await _container.StartAsync();
-
- var hostPort = _container.GetMappedPublicPort(5432);
- ConnectionString = $"Host=localhost;Port={hostPort};Username=test;Password=test;Database=testdb";
-
- // Run EF Core migrations here using the ConnectionString to prepare schema
- }
-
- public async Task DisposeAsync()
- {
- await _container.StopAsync();
- await _container.DisposeAsync();
- }
-}
-````
-
-### Wiring Testcontainers into WebApplicationFactory
-
-- In your `WebApplicationFactory` override, replace the application's DB connection string with the fixture-provided
- `ConnectionString` and ensure migrations run before tests execute.
-
-- Example in `ConfigureServices`:
-
-````csharp
-builder.ConfigureServices(services =>
-{
- // remove existing DbContext registration and add one that uses fixture.ConnectionString
-});
-````
-
-### Resetting DB state
-
-- Use `Respawn` against the Testcontainers database to truncate/reset between tests if you need to reuse the same DB
- instance.
-
-- For absolute isolation, consider creating a new schema or new database per test and dropping it afterwards (costlier
- but eliminates cross-test interference).
-
-## Reusable Fixtures and Lifetimes
-
-- For expensive shared resources, implement `IAsyncLifetime` in a fixture class and use `CollectionFixture` to share
- across tests.
-
-- Example: shared `TestAppFactory` and `TestDatabaseFixture` used via a collection:
-
-````csharp
-[CollectionDefinition("IntegrationTests")]
-public class IntegrationTestsCollection : ICollectionFixture, ICollectionFixture
-{
-}
-
-///
-/// Unit tests for the class.
-///
-[ExcludeFromCodeCoverage]
-[TestSubject(typeof(Article))]
-[Collection("IntegrationTests")]
-public class ArticleTests
-{
- private readonly TestAppFactory _factory;
- private readonly TestDatabaseFixture _db;
-
- public SomeIntegrationTests(TestAppFactory factory, TestDatabaseFixture db)
- {
- _factory = factory;
- _db = db;
- }
-
- [Fact]
- public async Task Get_Endpoint_ReturnsOk()
- {
- // Arrange
- var client = _factory.CreateClient();
-
- // Act
- var response = await client.GetAsync("/api/values");
-
- // Assert
- response.EnsureSuccessStatusCode();
- }
-}
-````
-
-## Playwright and Browser-based E2E
-
-- For full-browser tests use Playwright; manage the browser lifecycle in a shared fixture to avoid expensive repeated
- startup.
-
-- Use `Playwright.CreateAsync()` and `IBrowser` shared across tests or per-collection. Close/dispose in fixture
- teardown.
-
-- Protect credentials and secrets: use CI-provided secrets and do not commit sensitive data.
-
-## Environment and Configuration
-
-- Use explicit environment variables for integration tests (database connection strings, external service endpoints).
-- Provide a sample `appsettings.Integration.json` and a mechanism in the test factory to load it when
- `ASPNETCORE_ENVIRONMENT=Integration`.
-
-## Example: Database-backed Integration Test (EF Core)
-
-````csharp
-[Collection("IntegrationTests")]
-public class ArticlesEndpointTests
-{
- private readonly HttpClient _client;
-
- public ArticlesEndpointTests(TestAppFactory factory)
- {
- _client = factory.CreateClient();
- }
-
- [Fact]
- public async Task GetArticle_ReturnsArticleDto()
- {
- // Arrange: seed DB (via fixture or helper)
-
- // Act
- var res = await _client.GetAsync("/api/articles/1");
- res.EnsureSuccessStatusCode();
-
- var dto = await res.Content.ReadFromJsonAsync();
-
- // Assert
- dto.Should().NotBeNull();
- dto.Id.Should().Be(1);
- }
-}
-````
-
-## Edge Cases and Guidance
-
-- Network/timeouts: set generous timeouts for integration tests but fail fast on obvious configuration errors.
-- Flaky external services: stub or run a local emulator where possible. Use service virtualization for dependencies like
- SMTP, queues, or external APIs.
-
-- Parallelization: run independent tests in parallel, but for shared resources (e.g., a single test DB) use collections
- to serialize tests when necessary.
-
-## Test Naming and Structure
-
-- Use clear names: `Endpoint_Action_ExpectedResult` (e.g., `GetArticles_WhenExists_Returns200WithList`).
-- Keep tests focused on single behaviors; don't combine many assertions testing distinct behavior.
-
-## Example: Playwright E2E Test Fixture
-
-````csharp
-public class PlaywrightFixture : IAsyncLifetime
-{
- public IPlaywright Playwright { get; private set; }
- public IBrowser Browser { get; private set; }
-
- public async Task InitializeAsync()
- {
- Playwright = await Playwright.CreateAsync();
- Browser = await Playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions { Headless = true });
- }
-
- public async Task DisposeAsync()
- {
- await Browser?.CloseAsync();
- Playwright?.Dispose();
- }
-}
-````
-
-## CI Considerations
-
-- Use Docker Compose for reproducible services (DB, Redis, etc.) in CI and tear them down after tests.
-- Cache Playwright browsers in CI to reduce setup time.
-- Run integration tests in a separate pipeline stage so failures do not block quick CI feedback from unit tests.
-
-## Useful Libraries
-
-- `Microsoft.AspNetCore.Mvc.Testing` β host app in tests
-- `Respawn` β reset DB state between tests
-- `Playwright` β browser E2E tests
-- `DotNet.Testcontainers` β run ephemeral containers for DBs and services
-
-## Small Checklist
-
-- [ ] Use `WebApplicationFactory` or TestServer to host the app
-- [ ] Use deterministic/ephemeral DB strategy
-- [ ] Seed test data in fixtures
-- [ ] Use `CollectionFixture` for shared resources
-- [ ] Add `appsettings.Integration.json` and explicit environment settings
-- [ ] Add CI job/stage for integration tests
-
-Project setup (packages & templates)
-
-- Recommended packages: xunit, xunit.runner.visualstudio, Microsoft.NET.Test.Sdk, Microsoft.AspNetCore.Mvc.Testing,
- DotNet.Testcontainers, Npgsql.EntityFrameworkCore.PostgreSQL, FluentAssertions, Respawn (optional).
-
-- Recommended project template: create a new test project using the xUnit template (e.g.,
- `dotnet new xunit -n Web.Tests.Integration`) and add the packages above.
-
-# Aspire projects
-
-- If the solution is using the Aspire framework, create the integration test project from the "aspire-xunit" project
- template (e.g., `dotnet new aspire-xunit -n Web.Tests.Integration`) instead of the default xunit template. The "
- aspire-xunit" template ensures Aspire-specific test helpers, DI wiring, and conventions are present so the
- Testcontainers fixture and WebApplicationFactory integrate cleanly with the application's Aspire wiring.
-
-# Database strategy (Testcontainers-first)
-
-- Use DotNet.Testcontainers to run a real Postgres (or other) container per suite and a unique database name per
- factory/test to isolate state.
-
-```yaml
-name: Integration Tests
-
-on:
-workflow_dispatch:
-push:
-paths:
-
-- 'tests/Web.Tests.Integration/**'
-- '.github/workflows/integration-tests.yml'
-
-jobs:
-integration:
-runs-on: ubuntu-latest
-env:
-DOTNET_CLI_TELEMETRY_OPTOUT: '1'
-steps:
-
-- name: Checkout repo
-uses: actions/checkout@v4
-
- - name: Setup .NET
- uses: actions/setup-dotnet@v4
- with:
- dotnet-version: '9.0.x'
-
- - name: Ensure Docker is available
- run: docker version
-
- - name: Restore
- run: dotnet restore
-
- - name: Build
- run: dotnet build --configuration Release --no-restore
-
- - name: Run integration tests
- run: dotnet test tests/Web.Tests.Integration/Web.Tests.Integration.csproj --logger "trx;LogFileName=integration.trx" --verbosity normal --no-build
- env:
- DOTNET_TEST_CONTAINER_OVERRIDE: 'true'
-
-```
diff --git a/.github/prompts/xunit.prompt.md b/.github/prompts/xunit.prompt.md
deleted file mode 100644
index 618c3883..00000000
--- a/.github/prompts/xunit.prompt.md
+++ /dev/null
@@ -1,394 +0,0 @@
----
-agent: "agent"
-tools:
- [
- "changes",
- "search/codebase",
- "edit/editFiles",
- "problems",
- "search",
- "microsoft.docs.mcp/*",
- "fetch",
- "todos",
- ]
-description: "Get best practices for XUnit unit testing, including data-driven tests"
----
-
-# XUnit Best Practices
-
-You are an expert test developer and your goal is to help me write effective unit tests with XUnit v3, covering both
-standard and data-driven testing
-approaches. The goal is to create tests that fully tests all classes and methods excersizing them fully. Use the
-following guidelines and examples to create robust tests. Ensure to use the AAA (Arrange-Act-Assert)
-pattern. When applicable, prefer using data-driven tests with the `[Theory]` attribute and inline data. When dealing
-with references, move them into the GlobalUsings.cs file. When mocking dependencies, use a mocking library like
-NSubstitute or Moq.
-
-## Quick Tips
-
-- **Use `GlobalUsings.cs` for common references** (e.g., `using Xunit;`, `using FluentAssertions;`,
- `using NSubstitute;`). This keeps your test files clean and consistent.
-
-- **Test data management:** Use fakes, builders, or factories for generating test data. Prefer deterministic data for
- repeatable tests.
-
-- **Test discovery/filtering:** Use XUnit v3's improved test discovery and filtering (e.g.,
- `dotnet test --filter FullyQualifiedName~MyTest` or by trait/category).
-
-### Example: Testing a Blazor Article Component using XUnit
-
-```csharp
-
-using Xunit;
-using FluentAssertions;
-using Web.Data.Fakes;
-using Web.Data.Models;
-using JetBrains.Annotations;
-
-///
-/// Unit tests for the class.
-///
-[ExcludeFromCodeCoverage]
-public class ArticleTests
-{
- [Fact]
- public void DefaultConstructor_ShouldInitializeWithDefaults()
- {
-
- // Arrange & Act
- article = new Article();
-
- // Assert
- article.Title.Should().Be("");
- article.Introduction.Should().Be("");
- article.Content.Should().Be("");
- article.CoverImageUrl.Should().Be("");
- article.UrlSlug.Should().Be("");
- article.Author.Should().Be(ApplicationUserDto.Empty);
- article.Category.Should().Be(CategoryDto.Empty);
- article.IsPublished.Should().BeFalse();
- article.PublishedOn.Should().BeNull();
- article.IsArchived.Should().BeFalse();
- article.Tags.Should().BeEmpty();
-
- }
-```text
-
-## Project Setup
-
-- Use a separate test project with naming convention `[ProjectName].Tests.Unit`
-- Use the .NET SDK-style project format
-- Target the same framework as your main project (e.g., `net9.0`, `net10.0`)
-- Reference the same NuGet packages as your main project
-- Reference the same project references as your main project
-- Reference any additional dependencies required for testing
-- Set the project root namespace to match the project under test (e.g., `Web`)
-- Reference XUnit v3 packages: `xunit.v3.core`, `xunit.v3.assert`, and `xunit.v3.runner.visualstudio`
-- Also reference `Microsoft.NET.Test.Sdk`, `FluentAssertions`, and `bunit` packages for Blazor component/page testing
-- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`)
-- Use .NET SDK test commands: `dotnet test` for running tests
-- Add appropriate package references to your project file:
-
-```xml
-
-
-
-
-
-
-
-
-
-
-
-```text
-
-# Blazor Component and Page Testing with bUnit
-
-bUnit is the recommended library for unit testing Blazor components and pages. It integrates seamlessly with xUnit, NUnit, and MSTest, and runs tests in milliseconds. Key practices:
-
-- Add the `bunit` NuGet package to your test project.
-- Use `BunitContext` to render and interact with components in tests.
-- Use semantic HTML comparison and event simulation (e.g., `cut.Find("button").Click()`).
-- Pass parameters, cascading values, and inject services as needed.
-- **Mock dependencies like `IJSRuntime` and services for isolation:**
-
-```csharp
-
- JSInterop.Mode = JSRuntimeMode.Loose;
- JSInterop.Setup().SetResult("result");
- Services.AddSingleton(MockedService);
-
-```text
-
-- Use FluentAssertions for expressive assertions.
-
-### Example: Advanced bUnit Mocking
-
-```csharp
-
-using Bunit;
-using NSubstitute;
-using Xunit;
-
-public class MyComponentTests : BunitContext
-{
- [Fact]
- public void RendersWithMockedService()
- {
- // Arrange
- var service = Substitute.For();
- service.GetData().Returns("mocked");
- Services.AddSingleton(service);
-
- // Act
- var cut = RenderComponent();
-
- // Assert
- cut.Markup.Should().Contain("mocked");
- }
-}
-
-```text
-
-For more advanced scenarios, see the [bUnit documentation](https://bunit.dev/docs/getting-started/index.html).
-
-## Async and Exception Testing
-
-- Use async test methods for code that returns `Task`:
-
-```csharp
-
- [Fact]
- public async Task SaveAsync_ShouldPersistData()
- {
- // Arrange
- var repo = new Repository();
-
- // Act
- await repo.SaveAsync("data");
-
- // Assert
- var result = await repo.GetAsync();
- result.Should().Be("data");
- }
-
-```text
-
-- Test exceptions with FluentAssertions:
-
-```csharp
-
- [Fact]
- public void Method_ShouldThrowArgumentException()
- {
- // Arrange
- var obj = new MyClass();
-
- // Act
- Action act = () => obj.Method(null);
-
- // Assert
- act.Should().Throw().WithMessage("*null*");
- }
-
-```text
-
-For async:
-
-```csharp
-
-[Fact]
-public async Task MethodAsync_ShouldThrowInvalidOperationException()
-{
- // Arrange
- var obj = new MyClass();
-
- // Act
- Func act = async () => await obj.MethodAsync();
-
- // Assert
- await act.Should().ThrowAsync();
-}
-
-```text
-
-## Test Structure
-
-- No test class attributes required (unlike MSTest/NUnit)
-- Use fact-based tests with `[Fact]` attribute for simple tests
-- Use `[Theory]` attribute for data-driven tests
-- Strictly follow the Arrange-Act-Assert (AAA) pattern
-- **Arrange**: Set up test prerequisites and inputs
-- **Act**: Call the method or operation being tested
-- **Assert**: Verify the expected outcome using FluentAssertions
-- Use blank lines to separate each section of the AAA pattern for clarity
-- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior`
-- Use constructor for setup and `IDisposable.Dispose()` for teardown
-- Use `IClassFixture` for shared context between tests in a class
-- Use `ICollectionFixture` for shared context between multiple test classes
-
-## XUnit v3 Features
-
-- Use `[Test]` attribute instead of `[Fact]` (though `[Fact]` is still supported for backward compatibility)
-- Use `[Theory]` for data-driven tests (same as in XUnit v2)
-- Use the new `[Observation]` attribute for specification-style tests
-- Use `TestOutput` property for writing to test output (replaces `ITestOutputHelper`)
-- Strictly follow the Arrange-Act-Assert (AAA) pattern
-- **Arrange**: Set up test prerequisites and inputs
-- **Act**: Call the method or operation being tested
-- **Assert**: Verify the expected outcome using FluentAssertions
-- Leverage the improved assertion failure messages in XUnit v3
-- Take advantage of improved parallelization and performance in test runs
-- Use built-in asynchronous test methods with `async`/`await` support
-
-## Standard Tests
-
-- Keep tests focused on a single behavior
-- Avoid testing multiple behaviors in one test method
-- Use clear assertions that express intent
-- Include only the assertions needed to verify the test case
-- Make tests independent and idempotent (can run in any order)
-- Avoid test interdependencies
-
-## Data-Driven Tests
-
-- Use `[Theory]` combined with data source attributes
-- Use `[InlineData]` for inline test data
-- Use `[MemberData]` for method-based test data
-- Use `[ClassData]` for class-based test data
-- Create custom data attributes by implementing `DataAttribute`
-- Use meaningful parameter names in data-driven tests
-
-## Assertions with FluentAssertions
-
-- Use FluentAssertions for more readable and expressive assertions
-- Value equality: `result.Should().Be(expected)`
-- Reference equality: `result.Should().BeSameAs(expected)`
-- Boolean conditions: `result.Should().BeTrue()` or `result.Should().BeFalse()`
-- Collections:
-- `collection.Should().Contain(item)`
-- `collection.Should().NotContain(item)`
-- `collection.Should().HaveCount(count)`
-- `collection.Should().BeEmpty()`
-- Strings:
-- `string.Should().Contain("substring")`
-- `string.Should().StartWith("prefix")`
-- `string.Should().Match("regex pattern")`
-- Exceptions:
-- `Action act = () => methodThatThrows();`
-- `act.Should().Throw().WithMessage("*expected message*")`
-- For async: `Func act = async () => await asyncMethodThatThrows();`
-- `await act.Should().ThrowAsync()`
-- Types:
-- `obj.Should().BeOfType()`
-- `obj.Should().BeAssignableTo()`
-- Nullability:
-- `obj.Should().NotBeNull()`
-- `obj.Should().BeNull()`
-- Chain assertions for complex verifications:
-- `person.Should().NotBeNull().And.BeOfType().Which.Name.Should().StartWith("J")`
-
-## Mocking and Isolation
-
-- Use NSubstitute alongside XUnit (preferred over Moq in this project)
-- Mock dependencies to isolate units under test
-- Use interfaces to facilitate mocking
-- Consider using a DI container for complex test setups
-
-## Test Organization
-
-- Group tests by feature or component
-- Follow the folder structure of the main project
-- Use `[Trait("Category", "CategoryName")]` for categorization
-- Use collection fixtures to group tests with shared dependencies
-- Skip tests conditionally with `Skip = "reason"` in test attributes
-- Use XUnit v3's improved test discovery and filtering capabilities
-
-## Example with AAA Pattern
-
-```csharp
-
-[Test]
-public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
-{
- // Arrange
- var calculator = new Calculator();
- int a = 2;
- int b = 3;
-
- // Act
- int result = calculator.Add(a, b);
-
- // Assert
- result.Should().Be(5);
-}
-
-[Theory]
-[InlineData(0, 0, 0)]
-[InlineData(1, 2, 3)]
-[InlineData(-1, 1, 0)]
-public void Add_VariousInputs_ReturnsExpectedResults(int a, int b, int expected)
-{
- // Arrange
- var calculator = new Calculator();
-
- // Act
- int result = calculator.Add(a, b);
-
- // Assert
- result.Should().Be(expected);
-}
-
-// Example using new Observation attribute
-[Observation]
-public void Calculator_ShouldExist()
-{
- // Arrange & Act
- var calculator = new Calculator();
-
- // Assert
- calculator.Should().NotBeNull();
-}
-
-// Example with test output
-[Test]
-public void Add_WithLogging_ReturnsCorrectSum()
-{
- // Arrange
- var calculator = new Calculator();
- int a = 2;
- int b = 3;
-
- // Log test information
- TestOutput.WriteLine($"Testing addition with values {a} and {b}");
-
- // Act
- int result = calculator.Add(a, b);
-
- // Assert
- result.Should().Be(5);
- TestOutput.WriteLine($"Result was {result} as expected");
-}
-
-```text
-
-- Use async test methods for code that returns `Task`:
-
-```csharp
-
- [Fact]
- public async Task SaveAsync_ShouldPersistData()
- {
- // Arrange
- var repo = new Repository();
-
- // Act
- await repo.SaveAsync("data");
-
- // Assert
- var result = await repo.GetAsync();
- result.Should().Be("data");
- }
-
-```text
diff --git a/.github/skills/bunit-test-migration/SKILL.md b/.github/skills/bunit-test-migration/SKILL.md
deleted file mode 100644
index 3e64658a..00000000
--- a/.github/skills/bunit-test-migration/SKILL.md
+++ /dev/null
@@ -1,275 +0,0 @@
----
-name: bunit-test-migration
-description: Migrate bUnit test files from deprecated beta API (1.0.0-beta-10) to bUnit 2.x stable API. Use this when working on .razor test files in BlazorWebFormsComponents.Test that contain old patterns like TestComponentBase, Fixture, or SnapshotTest.
----
-
-# bUnit Test Migration Skill (Beta β 2.x)
-
-This skill provides guidance for migrating test files from the deprecated bUnit 1.0.0-beta-10 API to bUnit 2.5.3 stable API. Use this when you encounter test files using the old `TestComponentBase`, ``, or `` patterns.
-
-## When to Apply
-
-Apply this skill when a `.razor` test file contains any of these patterns:
-
-- `@inherits TestComponentBase`
-- ``
-- ``
-- ``
-- `void MethodName(Fixture fixture)`
-
-## Transformation Rules
-
-### 1. Change Inheritance
-
-```diff
-
-- @inherits TestComponentBase
-+ @inherits BunitContext
-```text
-
-### 2. Remove Wrapper Elements
-
-Remove these XML elements entirely (keep only the component inside):
-
-```diff
-
--
--
-
-
--
--
-```text
-
-### 3. Convert Test Methods
-
-```diff
-
-- void TestMethodName(Fixture fixture)
-+ [Fact]
-+ public void ComponentName_Scenario_ExpectedResult()
-```text
-
-### 4. Replace Component Access
-
-```diff
-
-- var cut = fixture.GetComponentUnderTest();
-+ var cut = Render(@);
-```text
-
-### 5. Convert Snapshot Tests
-
-```diff
-
--
--
--
--
--
--
expected html
--
--
-+ [Fact]
-+ public void MyComponent_Default_RendersCorrectly()
-+ {
-+ var cut = Render(@);
-+ cut.MarkupMatches(@
expected html
);
-+ }
-```text
-
-## Complete Example
-
-### Before
-
-```razor
-@inherits TestComponentBase
-
-
-
-
-
-
-
-@code {
- int ClickCount = 0;
-
- void ShouldClickButton(Fixture fixture)
- {
- var cut = fixture.GetComponentUnderTest();
-
- cut.Find("button").Click();
-
- ClickCount.ShouldBe(1);
- }
-
- void OnClick() => ClickCount++;
-}
-```text
-
-### After
-
-```razor
-@inherits BunitContext
-
-@code {
- int ClickCount = 0;
-
- [Fact]
- public void Button_Click_IncrementsCounter()
- {
- var cut = Render(@);
-
- cut.Find("button").Click();
-
- ClickCount.ShouldBe(1);
- }
-
- void OnClick() => ClickCount++;
-}
-```text
-
-## Test Naming Convention
-
-Pattern: `ComponentName_Scenario_ExpectedResult`
-
-| Component | Scenario | Result | Test Name |
-|-----------|----------|--------|-----------|
-| Button | Click | InvokesHandler | `Button_Click_InvokesHandler` |
-| DataList | EmptySource | ShowsEmptyTemplate | `DataList_EmptySource_ShowsEmptyTemplate` |
-| GridView | WithData | RendersRows | `GridView_WithData_RendersRows` |
-
-## Special Patterns
-
-### Multiple Tests in One File
-
-Each `` block becomes a separate `[Fact]` method:
-
-```razor
-@inherits BunitContext
-
-@code {
- [Fact]
- public void Component_FirstScenario_ExpectedResult() { ... }
-
- [Fact]
- public void Component_SecondScenario_ExpectedResult() { ... }
-}
-```text
-
-### Tests with Services
-
-```razor
-@code {
- [Fact]
- public void Component_WithService_Works()
- {
- Services.AddSingleton(new FakeService());
-
- var cut = Render(@);
- }
-}
-```text
-
-### Authentication Tests
-
-```razor
-@code {
- [Fact]
- public void SecureComponent_AuthenticatedUser_ShowsContent()
- {
- var authContext = this.AddTestAuthorization();
- authContext.SetAuthorized("TestUser");
- authContext.SetRoles("Admin");
-
- var cut = Render(@);
- }
-}
-```text
-
-### Tests Requiring New TestContext
-
-For tests that need isolated context (e.g., multiple renders):
-
-```razor
-@code {
- [Fact]
- public void Component_MultipleRenders_WorksCorrectly()
- {
- using var ctx = new Bunit.TestContext();
-
- var cut1 = ctx.Render(@);
- var cut2 = ctx.Render(@);
-
- cut1.Find("span").TextContent.ShouldBe("1");
- cut2.Find("span").TextContent.ShouldBe("2");
- }
-}
-```text
-
-### Tests with xUnit Logger (Optional)
-
-For debugging complex tests, you can optionally enable xUnit logging:
-
-```razor
-@using Microsoft.Extensions.Logging
-
-@code {
- private ILogger _logger;
-
- public MyTest(ITestOutputHelper output) : base(output)
- {
- }
-
- [Fact]
- public void Component_ComplexScenario_WorksAsExpected()
- {
- _logger = Services.GetService>();
- _logger?.LogInformation("Starting test");
-
- var cut = Render(@);
-
- _logger?.LogDebug("Component rendered");
-
- // Test assertions...
- }
-}
-```text
-
-**Note:** Only add logging when diagnostic output is helpful. Most tests should remain simple without logging.
-
-## Quick Reference Table
-
-| Old Pattern | New Pattern |
-|-------------|-------------|
-| `@inherits TestComponentBase` | `@inherits BunitContext` |
-| `` | Remove |
-| `` | Remove |
-| `` | `[Fact]` method with `MarkupMatches()` |
-| `void Name(Fixture fixture)` | `[Fact] public void Name()` |
-| `fixture.GetComponentUnderTest()` | `Render(@)` |
-| `fixture.GetComponentUnderTest()` | `Render(@)` |
-
-## Verification
-
-After migrating a file, verify with:
-
-```powershell
-# Build check
-dotnet build src/BlazorWebFormsComponents.Test --no-restore
-
-# List discovered tests
-dotnet test src/BlazorWebFormsComponents.Test --list-tests --filter "FullyQualifiedName~ComponentName"
-
-# Run tests
-dotnet test src/BlazorWebFormsComponents.Test --filter "FullyQualifiedName~ComponentName"
-```text
-
-## Common Errors
-
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `CS0246: TestComponentBase not found` | Old inheritance | Change to `@inherits BunitContext` |
-| `CS0103: Fixture does not exist` | Old wrapper element | Remove `` tags |
-| `No tests discovered` | Missing `[Fact]` attribute | Add `[Fact]` to test methods |
-| `Method must be public` | Private test method | Add `public` modifier |
diff --git a/.github/skills/code-review/SKILL.md b/.github/skills/code-review/SKILL.md
new file mode 100644
index 00000000..2fee91bd
--- /dev/null
+++ b/.github/skills/code-review/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: code-review
+description: >-
+ Code review for pull requests in IssueTracker, a Blazor Server issue tracker on MongoDB and .NET Aspire. Use when
+ reviewing a pull request or diff for correctness, repository standards, data access, security, tests, docs, and workflows.
+---
+
+# Code review
+
+Review the pull request against this repository's own sources of truth. The rules below point at them and add what
+they don't say. Every finding cites the file and rule it rests on.
+
+## Sources of truth
+
+Read the sections that govern the changed code before commenting on it:
+
+- `CLAUDE.md`: architecture, configuration, build and test commands, and workflow. It wins when another instruction
+ file disagrees.
+- `.editorconfig`: tabs, file-scoped namespaces, explicit types over `var`, and `System` usings first.
+- `.github/instructions/*.instructions.md`: Blazor, .NET, Markdown, MongoDB and blog post rules.
+- `.github/instructions/git-commit-instructions.md`: commit message format.
+
+## What to check
+
+**Layering.** Pages and components call services only. Flag a component that injects a repository, `IMongoDbContextFactory`
+or a MongoDB type, and a service that depends on a concrete repository instead of an interface from
+`PlugInRepositoryInterfaces/`. `Architecture.Tests` only covers part of this, so the review is the check.
+
+**Data access and caching.** Repositories in `IssueTracker.PlugIns/DataAccess` own every application-data query; the
+one other MongoDB call is the ping in `Helpers/MongoHealthCheck.cs`. A write path added or changed in a service must
+remove every `IMemoryCache` entry it affects, including per-user keys such as `GetIssuesByUser`'s; several existing
+write paths don't yet (#149). Flag a new query that loads a whole collection where a filter would do.
+
+**Models.** A change to a CoreBusiness model (`IssueModel`, `CommentModel`, ...) changes stored documents. Check that the
+matching `Basic*Model`, the Bogus fakes in `BogusFakes/`, and the repositories that project it still agree.
+
+**Security.** Protected pages need `@attribute [Authorize]`, with `Policy = "Admin"` for admin pages.
+`` isn't a security boundary. Redirect targets must be root-relative paths, never scheme-relative
+(`//host`) or absolute URLs. Flag secrets in code or `appsettings*.json`; configuration comes from user secrets and
+environment variables.
+
+**Tests.** Every new or changed behaviour has a test in the matching project, with `// Arrange`, `// Act` and
+`// Assert` markers. New component tests use bUnit's `BunitContext`, not the obsolete `TestContext`. Repository changes
+need an integration test in `IssueTracker.PlugIns.Tests.Integration`.
+
+**Build.** Builds run with `-warnaserror`. Flag a new `NoWarn` or `#pragma warning disable` without a comment saying why
+and when it goes away, and a `Version` on a `PackageReference` (Central Package Management owns versions).
+
+**Markdown.** Lines outside tables stay within 200 characters, and each file starts with one H1. CI's markdownlint
+enforces this and the other rules in `.markdownlint-cli2.jsonc`, except in the paths it ignores, such as the generated
+posts in `docs/blogs/`.
+
+**Workflows and hooks.** Actions are pinned immutably: a commit SHA with the version in a comment, a Docker image
+digest, or, for an action with no releases, a commit SHA with its source ref and date. Steps that publish anything
+(open a PR, push, tag, release) run only for `main`: a `github.ref == 'refs/heads/main'` check, or a merged-into-`main`
+condition as in `release.yml`. Pull request runs check out a detached merge commit, and fork PRs get a read-only token.
+`Build Solution` and `Test Suite` in `ci.yml` are required status checks on `main`, so they must run on every pull request.
+
+## Out of scope
+
+Leave compiler errors to the build. Spend comments on behaviour, boundaries, tests and intent.
diff --git a/.github/skills/github-issues/SKILL.md b/.github/skills/github-issues/SKILL.md
deleted file mode 100644
index 751d6288..00000000
--- a/.github/skills/github-issues/SKILL.md
+++ /dev/null
@@ -1,136 +0,0 @@
----
-name: github-issues
-description: 'Create, update, and manage GitHub issues using MCP tools. Use this skill when users want to create bug reports, feature requests, or task issues, update existing issues, add labels/assignees/milestones, or manage issue workflows. Triggers on requests like "create an issue", "file a bug", "request a feature", "update issue X", or any GitHub issue management task.'
----
-
-# GitHub Issues
-
-Manage GitHub issues using the `@modelcontextprotocol/server-github` MCP server.
-
-## Available MCP Tools
-
-| Tool | Purpose |
-|------|---------|
-| `mcp__github__create_issue` | Create new issues |
-| `mcp__github__update_issue` | Update existing issues |
-| `mcp__github__get_issue` | Fetch issue details |
-| `mcp__github__search_issues` | Search issues |
-| `mcp__github__add_issue_comment` | Add comments |
-| `mcp__github__list_issues` | List repository issues |
-
-## Workflow
-
-1. **Determine action**: Create, update, or query?
-
-2. **Gather context**: Get repo info, existing labels, milestones if needed
-
-3. **Structure content**: Use appropriate template from [references/templates.md](references/templates.md)
-
-4. **Execute**: Call the appropriate MCP tool
-
-5. **Confirm**: Report the issue URL to user
-
-## Creating Issues
-
-### Required Parameters
-
-```text
-owner: repository owner (org or user)
-repo: repository name
-title: clear, actionable title
-body: structured markdown content
-```text
-
-### Optional Parameters
-
-```json
-labels: ["bug", "enhancement", "documentation", ...]
-assignees: ["username1", "username2"]
-milestone: milestone number (integer)
-```text
-
-### Title Guidelines
-
-- Start with type prefix when useful: `[Bug]`, `[Feature]`, `[Docs]`
-- Be specific and actionable
-- Keep under 72 characters
-- Examples:
- - `[Bug] Login fails with SSO enabled`
- - `[Feature] Add dark mode support`
- - `Add unit tests for auth module`
-
-### Body Structure
-
-Always use the templates in [references/templates.md](references/templates.md). Choose based on issue type:
-
-| User Request | Template |
-|--------------|----------|
-| Bug, error, broken, not working | Bug Report |
-| Feature, enhancement, add, new | Feature Request |
-| Task, chore, refactor, update | Task |
-
-## Updating Issues
-
-Use `mcp__github__update_issue` with:
-
-```text
-owner, repo, issue_number (required)
-title, body, state, labels, assignees, milestone (optional - only changed fields)
-```text
-
-State values: `open`, `closed`
-
-## Examples
-
-### Example 1: Bug Report
-
-**User**: "Create a bug issue - the login page crashes when using SSO"
-
-**Action**: Call `mcp__github__create_issue` with:
-```json
-{
- "owner": "github",
- "repo": "awesome-copilot",
- "title": "[Bug] Login page crashes when using SSO",
- "body": "## Description\nThe login page crashes when users attempt to authenticate using SSO.\n\n## Steps to Reproduce\n1. Navigate to login page\n2. Click 'Sign in with SSO'\n3. Page crashes\n\n## Expected Behavior\nSSO authentication should complete and redirect to dashboard.\n\n## Actual Behavior\nPage becomes unresponsive and displays error.\n\n## Environment\n- Browser: [To be filled]\n- OS: [To be filled]\n\n## Additional Context\nReported by user.",
- "labels": ["bug"]
-}
-```text
-
-### Example 2: Feature Request
-
-**User**: "Create a feature request for dark mode with high priority"
-
-**Action**: Call `mcp__github__create_issue` with:
-```json
-{
- "owner": "github",
- "repo": "awesome-copilot",
- "title": "[Feature] Add dark mode support",
- "body": "## Summary\nAdd dark mode theme option for improved user experience and accessibility.\n\n## Motivation\n- Reduces eye strain in low-light environments\n- Increasingly expected by users\n- Improves accessibility\n\n## Proposed Solution\nImplement theme toggle with system preference detection.\n\n## Acceptance Criteria\n- [ ] Toggle switch in settings\n- [ ] Persists user preference\n- [ ] Respects system preference by default\n- [ ] All UI components support both themes\n\n## Alternatives Considered\nNone specified.\n\n## Additional Context\nHigh priority request.",
- "labels": ["enhancement", "high-priority"]
-}
-```text
-
-## Common Labels
-
-Use these standard labels when applicable:
-
-| Label | Use For |
-|-------|---------|
-| `bug` | Something isn't working |
-| `enhancement` | New feature or improvement |
-| `documentation` | Documentation updates |
-| `good first issue` | Good for newcomers |
-| `help wanted` | Extra attention needed |
-| `question` | Further information requested |
-| `wontfix` | Will not be addressed |
-| `duplicate` | Already exists |
-| `high-priority` | Urgent issues |
-
-## Tips
-
-- Always confirm the repository context before creating issues
-- Ask for missing critical information rather than guessing
-- Link related issues when known: `Related to #123`
-- For updates, fetch current issue first to preserve unchanged fields
diff --git a/.github/skills/github-issues/references/templates.md b/.github/skills/github-issues/references/templates.md
deleted file mode 100644
index 61a0c3fe..00000000
--- a/.github/skills/github-issues/references/templates.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# Issue Templates
-
-Copy and customize these templates for issue bodies.
-
-## Bug Report Template
-
-```markdown
-## Description
-[Clear description of the bug]
-
-## Steps to Reproduce
-1. [First step]
-
-2. [Second step]
-
-3. [And so on...]
-
-## Expected Behavior
-[What should happen]
-
-## Actual Behavior
-[What actually happens]
-
-## Environment
-- Browser: [e.g., Chrome 120]
-- OS: [e.g., macOS 14.0]
-- Version: [e.g., v1.2.3]
-
-## Screenshots/Logs
-[If applicable]
-
-## Additional Context
-[Any other relevant information]
-```text
-
-## Feature Request Template
-
-```markdown
-## Summary
-[One-line description of the feature]
-
-## Motivation
-[Why is this feature needed? What problem does it solve?]
-
-## Proposed Solution
-[How should this feature work?]
-
-## Acceptance Criteria
-- [ ] [Criterion 1]
-- [ ] [Criterion 2]
-- [ ] [Criterion 3]
-
-## Alternatives Considered
-[Other approaches considered and why they weren't chosen]
-
-## Additional Context
-[Mockups, examples, or related issues]
-```text
-
-## Task Template
-
-```markdown
-## Objective
-[What needs to be accomplished]
-
-## Details
-[Detailed description of the work]
-
-## Checklist
-- [ ] [Subtask 1]
-- [ ] [Subtask 2]
-- [ ] [Subtask 3]
-
-## Dependencies
-[Any blockers or related work]
-
-## Notes
-[Additional context or considerations]
-```text
-
-## Minimal Template
-
-For simple issues:
-
-```markdown
-## Description
-[What and why]
-
-## Tasks
-- [ ] [Task 1]
-- [ ] [Task 2]
-```text
diff --git a/.github/skills/microsoft-docs/SKILL.md b/.github/skills/microsoft-docs/SKILL.md
deleted file mode 100644
index 92927a89..00000000
--- a/.github/skills/microsoft-docs/SKILL.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-name: microsoft-docs
-description: Query official Microsoft documentation to understand concepts, find tutorials, and learn how services work. Use for Azure, .NET, Microsoft 365, Windows, Power Platform, and all Microsoft technologies. Get accurate, current information from learn.microsoft.com and other official Microsoft websitesβarchitecture overviews, quickstarts, configuration guides, limits, and best practices.
-compatibility: Requires Microsoft Learn MCP Server (https://learn.microsoft.com/api/mcp)
----
-
-# Microsoft Docs
-
-## Tools
-
-| Tool | Use For |
-|------|---------|
-| `microsoft_docs_search` | Find documentationβconcepts, guides, tutorials, configuration |
-| `microsoft_docs_fetch` | Get full page content (when search excerpts aren't enough) |
-
-## When to Use
-
-- **Understanding concepts** β "How does Cosmos DB partitioning work?"
-- **Learning a service** β "Azure Functions overview", "Container Apps architecture"
-- **Finding tutorials** β "quickstart", "getting started", "step-by-step"
-- **Configuration options** β "App Service configuration settings"
-- **Limits & quotas** β "Azure OpenAI rate limits", "Service Bus quotas"
-- **Best practices** β "Azure security best practices"
-
-## Query Effectiveness
-
-Good queries are specific:
-
-```text
-# β Too broad
-"Azure Functions"
-
-# β Specific
-"Azure Functions Python v2 programming model"
-"Cosmos DB partition key design best practices"
-"Container Apps scaling rules KEDA"
-```text
-
-Include context:
-- **Version** when relevant (`.NET 8`, `EF Core 8`)
-- **Task intent** (`quickstart`, `tutorial`, `overview`, `limits`)
-- **Platform** for multi-platform docs (`Linux`, `Windows`)
-
-## When to Fetch Full Page
-
-Fetch after search when:
-- **Tutorials** β need complete step-by-step instructions
-- **Configuration guides** β need all options listed
-- **Deep dives** β user wants comprehensive coverage
-- **Search excerpt is cut off** β full context needed
-
-## Why Use This
-
-- **Accuracy** β live docs, not training data that may be outdated
-- **Completeness** β tutorials have all steps, not fragments
-- **Authority** β official Microsoft documentation
diff --git a/.github/skills/nuget-manager/SKILL.md b/.github/skills/nuget-manager/SKILL.md
deleted file mode 100644
index d7edd58a..00000000
--- a/.github/skills/nuget-manager/SKILL.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-name: nuget-manager
-description: 'Manage NuGet packages in .NET projects/solutions. Use this skill when adding, removing, or updating NuGet package versions. It enforces using `dotnet` CLI for package management and provides strict procedures for direct file edits only when updating versions.'
----
-
-# NuGet Manager
-
-## Overview
-
-This skill ensures consistent and safe management of NuGet packages across .NET projects. It prioritizes using the `dotnet` CLI to maintain project integrity and enforces a strict verification and restoration workflow for version updates.
-
-## Prerequisites
-
-- .NET SDK installed (typically .NET 8.0 SDK or later, or a version compatible with the target solution).
-- `dotnet` CLI available on your `PATH`.
-- `jq` (JSON processor) OR PowerShell (for version verification using `dotnet package search`).
-
-## Core Rules
-
-1. **NEVER** directly edit `.csproj`, `.props`, or `Directory.Packages.props` files to **add** or **remove** packages. Always use `dotnet add package` and `dotnet remove package` commands.
-
-2. **DIRECT EDITING** is ONLY permitted for **changing versions** of existing packages.
-
-3. **VERSION UPDATES** must follow the mandatory workflow:
- - Verify the target version exists on NuGet.
- - Determine if versions are managed per-project (`.csproj`) or centrally (`Directory.Packages.props`).
- - Update the version string in the appropriate file.
- - Immediately run `dotnet restore` to verify compatibility.
-
-## Workflows
-
-### Adding a Package
-
-Use `dotnet add [] package [--version ]`.
-Example: `dotnet add src/MyProject/MyProject.csproj package Newtonsoft.Json`
-
-### Removing a Package
-
-Use `dotnet remove [] package `.
-Example: `dotnet remove src/MyProject/MyProject.csproj package Newtonsoft.Json`
-
-### Updating Package Versions
-
-When updating a version, follow these steps:
-
-1. **Verify Version Existence**:
- Check if the version exists using the `dotnet package search` command with exact match and JSON formatting.
- Using `jq`:
- `dotnet package search --exact-match --format json | jq -e '.searchResult[].packages[] | select(.version == "")'`
- Using PowerShell:
- `(dotnet package search --exact-match --format json | ConvertFrom-Json).searchResult.packages | Where-Object { $_.version -eq "" }`
-
-2. **Determine Version Management**:
- - Search for `Directory.Packages.props` in the solution root. If present, versions should be managed there via ``.
- - If absent, check individual `.csproj` files for ``.
-
-3. **Apply Changes**:
- Modify the identified file with the new version string.
-
-4. **Verify Stability**:
- Run `dotnet restore` on the project or solution. If errors occur, revert the change and investigate.
-
-## Examples
-
-### User: "Add Serilog to the WebApi project"
-
-**Action**: Execute `dotnet add src/WebApi/WebApi.csproj package Serilog`.
-
-### User: "Update Newtonsoft.Json to 13.0.3 in the whole solution"
-
-**Action**:
-
-1. Verify 13.0.3 exists: `dotnet package search Newtonsoft.Json --exact-match --format json` (and parse output to confirm "13.0.3" is present).
-
-2. Find where it's defined (e.g., `Directory.Packages.props`).
-
-3. Edit the file to update the version.
-
-4. Run `dotnet restore`.
diff --git a/.github/skills/prd/SKILL.md b/.github/skills/prd/SKILL.md
deleted file mode 100644
index a155da1a..00000000
--- a/.github/skills/prd/SKILL.md
+++ /dev/null
@@ -1,143 +0,0 @@
----
-name: prd
-description: 'Generate high-quality Product Requirements Documents (PRDs) for software systems and AI-powered features. Includes executive summaries, user stories, technical specifications, and risk analysis.'
-license: MIT
----
-
-# Product Requirements Document (PRD)
-
-## Overview
-
-Design comprehensive, production-grade Product Requirements Documents (PRDs) that bridge the gap between business vision and technical execution. This skill works for modern software systems, ensuring that requirements are clearly defined.
-
-## When to Use
-
-Use this skill when:
-
-- Starting a new product or feature development cycle
-- Translating a vague idea into a concrete technical specification
-- Defining requirements for AI-powered features
-- Stakeholders need a unified "source of truth" for project scope
-- User asks to "write a PRD", "document requirements", or "plan a feature"
-
----
-
-## Operational Workflow
-
-### Phase 1: Discovery (The Interview)
-
-Before writing a single line of the PRD, you **MUST** interrogate the user to fill knowledge gaps. Do not assume context.
-
-**Ask about:**
-
-- **The Core Problem**: Why are we building this now?
-- **Success Metrics**: How do we know it worked?
-- **Constraints**: Budget, tech stack, or deadline?
-
-### Phase 2: Analysis & Scoping
-
-Synthesize the user's input. Identify dependencies and hidden complexities.
-
-- Map out the **User Flow**.
-- Define **Non-Goals** to protect the timeline.
-
-### Phase 3: Technical Drafting
-
-Generate the document using the **Strict PRD Schema** below.
-
----
-
-## PRD Quality Standards
-
-### Requirements Quality
-
-Use concrete, measurable criteria. Avoid "fast", "easy", or "intuitive".
-
-```diff
-# Vague (BAD)
-- The search should be fast and return relevant results.
-- The UI must look modern and be easy to use.
-
-# Concrete (GOOD)
-+ The search must return results within 200ms for a 10k record dataset.
-+ The search algorithm must achieve >= 85% Precision@10 in benchmark evals.
-+ The UI must follow the 'Vercel/Next.js' design system and achieve 100% Lighthouse Accessibility score.
-```text
-
----
-
-## Strict PRD Schema
-
-You **MUST** follow this exact structure for the output:
-
-### 1. Executive Summary
-
-- **Problem Statement**: 1-2 sentences on the pain point.
-- **Proposed Solution**: 1-2 sentences on the fix.
-- **Success Criteria**: 3-5 measurable KPIs.
-
-### 2. User Experience & Functionality
-
-- **User Personas**: Who is this for?
-- **User Stories**: `As a [user], I want to [action] so that [benefit].`
-- **Acceptance Criteria**: Bulleted list of "Done" definitions for each story.
-- **Non-Goals**: What are we NOT building?
-
-### 3. AI System Requirements (If Applicable)
-
-- **Tool Requirements**: What tools and APIs are needed?
-- **Evaluation Strategy**: How to measure output quality and accuracy.
-
-### 4. Technical Specifications
-
-- **Architecture Overview**: Data flow and component interaction.
-- **Integration Points**: APIs, DBs, and Auth.
-- **Security & Privacy**: Data handling and compliance.
-
-### 5. Risks & Roadmap
-
-- **Phased Rollout**: MVP -> v1.1 -> v2.0.
-- **Technical Risks**: Latency, cost, or dependency failures.
-
----
-
-## Implementation Guidelines
-
-### DO (Always)
-
-- **Define Testing**: For AI systems, specify how to test and validate output quality.
-- **Iterate**: Present a draft and ask for feedback on specific sections.
-
-### DON'T (Avoid)
-
-- **Skip Discovery**: Never write a PRD without asking at least 2 clarifying questions first.
-- **Hallucinate Constraints**: If the user didn't specify a tech stack, ask or label it as `TBD`.
-
----
-
-## Example: Intelligent Search System
-
-### 1. Executive Summary
-
-**Problem**: Users struggle to find specific documentation snippets in massive repositories.
-**Solution**: An intelligent search system that provides direct answers with source citations.
-**Success**:
-
-- Reduce search time by 50%.
-- Citation accuracy >= 95%.
-
-### 2. User Stories
-
-- **Story**: As a developer, I want to ask natural language questions so I don't have to guess keywords.
-- **AC**:
- - Supports multi-turn clarification.
- - Returns code blocks with "Copy" button.
-
-### 3. AI System Architecture
-
-- **Tools Required**: `codesearch`, `grep`, `webfetch`.
-
-### 4. Evaluation
-
-- **Benchmark**: Test with 50 common developer questions.
-- **Pass Rate**: 90% must match expected citations.
diff --git a/.github/skills/refactor/SKILL.md b/.github/skills/refactor/SKILL.md
deleted file mode 100644
index 3b6dc322..00000000
--- a/.github/skills/refactor/SKILL.md
+++ /dev/null
@@ -1,656 +0,0 @@
----
-name: refactor
-description: 'Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.'
-license: MIT
----
-
-# Refactor
-
-## Overview
-
-Improve code structure and readability without changing external behavior. Refactoring is gradual evolution, not revolution. Use this for improving existing code, not rewriting from scratch.
-
-## When to Use
-
-Use this skill when:
-
-- Code is hard to understand or maintain
-- Functions/classes are too large
-- Code smells need addressing
-- Adding features is difficult due to code structure
-- User asks "clean up this code", "refactor this", "improve this"
-
----
-
-## Refactoring Principles
-
-### The Golden Rules
-
-1. **Behavior is preserved** - Refactoring doesn't change what the code does, only how
-
-2. **Small steps** - Make tiny changes, test after each
-
-3. **Version control is your friend** - Commit before and after each safe state
-
-4. **Tests are essential** - Without tests, you're not refactoring, you're editing
-
-5. **One thing at a time** - Don't mix refactoring with feature changes
-
-### When NOT to Refactor
-
-```text
-
-- Code that works and won't change again (if it ain't broke...)
-- Critical production code without tests (add tests first)
-- When you're under a tight deadline
-- "Just because" - need a clear purpose
-```text
-
----
-
-## Common Code Smells & Fixes
-
-### 1. Long Method/Function
-
-```diff
-# BAD: 200-line function that does everything
-- async function processOrder(orderId) {
-- // 50 lines: fetch order
-- // 30 lines: validate order
-- // 40 lines: calculate pricing
-- // 30 lines: update inventory
-- // 20 lines: create shipment
-- // 30 lines: send notifications
-- }
-
-# GOOD: Broken into focused functions
-+ async function processOrder(orderId) {
-+ const order = await fetchOrder(orderId);
-+ validateOrder(order);
-+ const pricing = calculatePricing(order);
-+ await updateInventory(order);
-+ const shipment = await createShipment(order);
-+ await sendNotifications(order, pricing, shipment);
-+ return { order, pricing, shipment };
-+ }
-```text
-
-### 2. Duplicated Code
-
-```diff
-# BAD: Same logic in multiple places
-- function calculateUserDiscount(user) {
-- if (user.membership === 'gold') return user.total * 0.2;
-- if (user.membership === 'silver') return user.total * 0.1;
-- return 0;
-- }
--
-- function calculateOrderDiscount(order) {
-- if (order.user.membership === 'gold') return order.total * 0.2;
-- if (order.user.membership === 'silver') return order.total * 0.1;
-- return 0;
-- }
-
-# GOOD: Extract common logic
-+ function getMembershipDiscountRate(membership) {
-+ const rates = { gold: 0.2, silver: 0.1 };
-+ return rates[membership] || 0;
-+ }
-+
-+ function calculateUserDiscount(user) {
-+ return user.total * getMembershipDiscountRate(user.membership);
-+ }
-+
-+ function calculateOrderDiscount(order) {
-+ return order.total * getMembershipDiscountRate(order.user.membership);
-+ }
-```text
-
-### 3. Large Class/Module
-
-```diff
-# BAD: God object that knows too much
-- class UserManager {
-- createUser() { /* ... */ }
-- updateUser() { /* ... */ }
-- deleteUser() { /* ... */ }
-- sendEmail() { /* ... */ }
-- generateReport() { /* ... */ }
-- handlePayment() { /* ... */ }
-- validateAddress() { /* ... */ }
-- // 50 more methods...
-- }
-
-# GOOD: Single responsibility per class
-+ class UserService {
-+ create(data) { /* ... */ }
-+ update(id, data) { /* ... */ }
-+ delete(id) { /* ... */ }
-+ }
-+
-+ class EmailService {
-+ send(to, subject, body) { /* ... */ }
-+ }
-+
-+ class ReportService {
-+ generate(type, params) { /* ... */ }
-+ }
-+
-+ class PaymentService {
-+ process(amount, method) { /* ... */ }
-+ }
-```text
-
-### 4. Long Parameter List
-
-```diff
-# BAD: Too many parameters
-- function createUser(email, password, name, age, address, city, country, phone) {
-- /* ... */
-- }
-
-# GOOD: Group related parameters
-+ interface UserData {
-+ email: string;
-+ password: string;
-+ name: string;
-+ age?: number;
-+ address?: Address;
-+ phone?: string;
-+ }
-+
-+ function createUser(data: UserData) {
-+ /* ... */
-+ }
-
-# EVEN BETTER: Use builder pattern for complex construction
-+ const user = UserBuilder
-+ .email('test@example.com')
-+ .password('secure123')
-+ .name('Test User')
-+ .address(address)
-+ .build();
-```text
-
-### 5. Feature Envy
-
-```diff
-# BAD: Method that uses another object's data more than its own
-- class Order {
-- calculateDiscount(user) {
-- if (user.membershipLevel === 'gold') {
-+ return this.total * 0.2;
-+ }
-+ if (user.accountAge > 365) {
-+ return this.total * 0.1;
-+ }
-+ return 0;
-+ }
-+ }
-
-# GOOD: Move logic to the object that owns the data
-+ class User {
-+ getDiscountRate(orderTotal) {
-+ if (this.membershipLevel === 'gold') return 0.2;
-+ if (this.accountAge > 365) return 0.1;
-+ return 0;
-+ }
-+ }
-+
-+ class Order {
-+ calculateDiscount(user) {
-+ return this.total * user.getDiscountRate(this.total);
-+ }
-+ }
-```text
-
-### 6. Primitive Obsession
-
-```diff
-# BAD: Using primitives for domain concepts
-- function sendEmail(to, subject, body) { /* ... */ }
-- sendEmail('user@example.com', 'Hello', '...');
-
-- function createPhone(country, number) {
-- return `${country}-${number}`;
-- }
-
-# GOOD: Use domain types
-+ class Email {
-+ private constructor(public readonly value: string) {
-+ if (!Email.isValid(value)) throw new Error('Invalid email');
-+ }
-+ static create(value: string) { return new Email(value); }
-+ static isValid(email: string) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email); }
-+ }
-+
-+ class PhoneNumber {
-+ constructor(
-+ public readonly country: string,
-+ public readonly number: string
-+ ) {
-+ if (!PhoneNumber.isValid(country, number)) throw new Error('Invalid phone');
-+ }
-+ toString() { return `${this.country}-${this.number}`; }
-+ static isValid(country: string, number: string) { /* ... */ }
-+ }
-+
-+ // Usage
-+ const email = Email.create('user@example.com');
-+ const phone = new PhoneNumber('1', '555-1234');
-```text
-
-### 7. Magic Numbers/Strings
-
-```diff
-# BAD: Unexplained values
-- if (user.status === 2) { /* ... */ }
-- const discount = total * 0.15;
-- setTimeout(callback, 86400000);
-
-# GOOD: Named constants
-+ const UserStatus = {
-+ ACTIVE: 1,
-+ INACTIVE: 2,
-+ SUSPENDED: 3
-+ } as const;
-+
-+ const DISCOUNT_RATES = {
-+ STANDARD: 0.1,
-+ PREMIUM: 0.15,
-+ VIP: 0.2
-+ } as const;
-+
-+ const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-+
-+ if (user.status === UserStatus.INACTIVE) { /* ... */ }
-+ const discount = total * DISCOUNT_RATES.PREMIUM;
-+ setTimeout(callback, ONE_DAY_MS);
-```text
-
-### 8. Nested Conditionals
-
-```diff
-# BAD: Arrow code
-- function process(order) {
-- if (order) {
-- if (order.user) {
-- if (order.user.isActive) {
-- if (order.total > 0) {
-- return processOrder(order);
-+ } else {
-+ return { error: 'Invalid total' };
-+ }
-+ } else {
-+ return { error: 'User inactive' };
-+ }
-+ } else {
-+ return { error: 'No user' };
-+ }
-+ } else {
-+ return { error: 'No order' };
-+ }
-+ }
-
-# GOOD: Guard clauses / early returns
-+ function process(order) {
-+ if (!order) return { error: 'No order' };
-+ if (!order.user) return { error: 'No user' };
-+ if (!order.user.isActive) return { error: 'User inactive' };
-+ if (order.total <= 0) return { error: 'Invalid total' };
-+ return processOrder(order);
-+ }
-
-# EVEN BETER: Using Result type
-+ function process(order): Result {
-+ return Result.combine([
-+ validateOrderExists(order),
-+ validateUserExists(order),
-+ validateUserActive(order.user),
-+ validateOrderTotal(order)
-+ ]).flatMap(() => processOrder(order));
-+ }
-```text
-
-### 9. Dead Code
-
-```diff
-# BAD: Unused code lingers
-- function oldImplementation() { /* ... */ }
-- const DEPRECATED_VALUE = 5;
-- import { unusedThing } from './somewhere';
-- // Commented out code
-- // function oldCode() { /* ... */ }
-
-# GOOD: Remove it
-+ // Delete unused functions, imports, and commented code
-+ // If you need it again, git history has it
-```text
-
-### 10. Inappropriate Intimacy
-
-```diff
-# BAD: One class reaches deep into another
-- class OrderProcessor {
-- process(order) {
-- order.user.profile.address.street; // Too intimate
-- order.repository.connection.config; // Breaking encapsulation
-+ }
-+ }
-
-# GOOD: Ask, don't tell
-+ class OrderProcessor {
-+ process(order) {
-+ order.getShippingAddress(); // Order knows how to get it
-+ order.save(); // Order knows how to save itself
-+ }
-+ }
-```text
-
----
-
-## Extract Method Refactoring
-
-### Before and After
-
-```diff
-# Before: One long function
-- function printReport(users) {
-- console.log('USER REPORT');
-- console.log('============');
-- console.log('');
-- console.log(`Total users: ${users.length}`);
-- console.log('');
-- console.log('ACTIVE USERS');
-- console.log('------------');
-- const active = users.filter(u => u.isActive);
-- active.forEach(u => {
-- console.log(`- ${u.name} (${u.email})`);
-- });
-- console.log('');
-- console.log(`Active: ${active.length}`);
-- console.log('');
-- console.log('INACTIVE USERS');
-- console.log('--------------');
-- const inactive = users.filter(u => !u.isActive);
-- inactive.forEach(u => {
-- console.log(`- ${u.name} (${u.email})`);
-- });
-- console.log('');
-- console.log(`Inactive: ${inactive.length}`);
-- }
-
-# After: Extracted methods
-+ function printReport(users) {
-+ printHeader('USER REPORT');
-+ console.log(`Total users: ${users.length}\n`);
-+ printUserSection('ACTIVE USERS', users.filter(u => u.isActive));
-+ printUserSection('INACTIVE USERS', users.filter(u => !u.isActive));
-+ }
-+
-+ function printHeader(title) {
-+ const line = '='.repeat(title.length);
-+ console.log(title);
-+ console.log(line);
-+ console.log('');
-+ }
-+
-+ function printUserSection(title, users) {
-+ console.log(title);
-+ console.log('-'.repeat(title.length));
-+ users.forEach(u => console.log(`- ${u.name} (${u.email})`));
-+ console.log('');
-+ console.log(`${title.split(' ')[0]}: ${users.length}`);
-+ console.log('');
-+ }
-```text
-
----
-
-## Introducing Type Safety
-
-### From Untyped to Typed
-
-```diff
-# Before: No types
-- function calculateDiscount(user, total, membership, date) {
-- if (membership === 'gold' && date.getDay() === 5) {
-- return total * 0.25;
-- }
-- if (membership === 'gold') return total * 0.2;
-- return total * 0.1;
-- }
-
-# After: Full type safety
-+ type Membership = 'bronze' | 'silver' | 'gold';
-+
-+ interface User {
-+ id: string;
-+ name: string;
-+ membership: Membership;
-+ }
-+
-+ interface DiscountResult {
-+ original: number;
-+ discount: number;
-+ final: number;
-+ rate: number;
-+ }
-+
-+ function calculateDiscount(
-+ user: User,
-+ total: number,
-+ date: Date = new Date()
-+ ): DiscountResult {
-+ if (total < 0) throw new Error('Total cannot be negative');
-+
-+ let rate = 0.1; // Default bronze
-+
-+ if (user.membership === 'gold' && date.getDay() === 5) {
-+ rate = 0.25; // Friday bonus for gold
-+ } else if (user.membership === 'gold') {
-+ rate = 0.2;
-+ } else if (user.membership === 'silver') {
-+ rate = 0.15;
-+ }
-+
-+ const discount = total * rate;
-+
-+ return {
-+ original: total,
-+ discount,
-+ final: total - discount,
-+ rate
-+ };
-+ }
-```text
-
----
-
-## Design Patterns for Refactoring
-
-### Strategy Pattern
-
-```diff
-# Before: Conditional logic
-- function calculateShipping(order, method) {
-- if (method === 'standard') {
-- return order.total > 50 ? 0 : 5.99;
-- } else if (method === 'express') {
-- return order.total > 100 ? 9.99 : 14.99;
-+ } else if (method === 'overnight') {
-+ return 29.99;
-+ }
-+ }
-
-# After: Strategy pattern
-+ interface ShippingStrategy {
-+ calculate(order: Order): number;
-+ }
-+
-+ class StandardShipping implements ShippingStrategy {
-+ calculate(order: Order) {
-+ return order.total > 50 ? 0 : 5.99;
-+ }
-+ }
-+
-+ class ExpressShipping implements ShippingStrategy {
-+ calculate(order: Order) {
-+ return order.total > 100 ? 9.99 : 14.99;
-+ }
-+ }
-+
-+ class OvernightShipping implements ShippingStrategy {
-+ calculate(order: Order) {
-+ return 29.99;
-+ }
-+ }
-+
-+ function calculateShipping(order: Order, strategy: ShippingStrategy) {
-+ return strategy.calculate(order);
-+ }
-```text
-
-### Chain of Responsibility
-
-```diff
-# Before: Nested validation
-- function validate(user) {
-- const errors = [];
-- if (!user.email) errors.push('Email required');
-+ else if (!isValidEmail(user.email)) errors.push('Invalid email');
-+ if (!user.name) errors.push('Name required');
-+ if (user.age < 18) errors.push('Must be 18+');
-+ if (user.country === 'blocked') errors.push('Country not supported');
-+ return errors;
-+ }
-
-# After: Chain of responsibility
-+ abstract class Validator {
-+ abstract validate(user: User): string | null;
-+ setNext(validator: Validator): Validator {
-+ this.next = validator;
-+ return validator;
-+ }
-+ validate(user: User): string | null {
-+ const error = this.doValidate(user);
-+ if (error) return error;
-+ return this.next?.validate(user) ?? null;
-+ }
-+ }
-+
-+ class EmailRequiredValidator extends Validator {
-+ doValidate(user: User) {
-+ return !user.email ? 'Email required' : null;
-+ }
-+ }
-+
-+ class EmailFormatValidator extends Validator {
-+ doValidate(user: User) {
-+ return user.email && !isValidEmail(user.email) ? 'Invalid email' : null;
-+ }
-+ }
-+
-+ // Build the chain
-+ const validator = new EmailRequiredValidator()
-+ .setNext(new EmailFormatValidator())
-+ .setNext(new NameRequiredValidator())
-+ .setNext(new AgeValidator())
-+ .setNext(new CountryValidator());
-```text
-
----
-
-## Refactoring Steps
-
-### Safe Refactoring Process
-
-```text
-
-1. PREPARE
-
- - Ensure tests exist (write them if missing)
- - Commit current state
- - Create feature branch
-
-2. IDENTIFY
-
- - Find the code smell to address
- - Understand what the code does
- - Plan the refactoring
-
-3. REFACTOR (small steps)
-
- - Make one small change
- - Run tests
- - Commit if tests pass
- - Repeat
-
-4. VERIFY
-
- - All tests pass
- - Manual testing if needed
- - Performance unchanged or improved
-
-5. CLEAN UP
-
- - Update comments
- - Update documentation
- - Final commit
-```text
-
----
-
-## Refactoring Checklist
-
-### Code Quality
-
-- [ ] Functions are small (< 50 lines)
-- [ ] Functions do one thing
-- [ ] No duplicated code
-- [ ] Descriptive names (variables, functions, classes)
-- [ ] No magic numbers/strings
-- [ ] Dead code removed
-
-### Structure
-
-- [ ] Related code is together
-- [ ] Clear module boundaries
-- [ ] Dependencies flow in one direction
-- [ ] No circular dependencies
-
-### Type Safety
-
-- [ ] Types defined for all public APIs
-- [ ] No `any` types without justification
-- [ ] Nullable types explicitly marked
-
-### Testing
-
-- [ ] Refactored code is tested
-- [ ] Tests cover edge cases
-- [ ] All tests pass
-
----
-
-## Common Refactoring Operations
-
-| Operation | Description |
-| --------------------------------------------- | ------------------------------------- |
-| Extract Method | Turn code fragment into method |
-| Extract Class | Move behavior to new class |
-| Extract Interface | Create interface from implementation |
-| Inline Method | Move method body back to caller |
-| Inline Class | Move class behavior to caller |
-| Pull Up Method | Move method to superclass |
-| Push Down Method | Move method to subclass |
-| Rename Method/Variable | Improve clarity |
-| Introduce Parameter Object | Group related parameters |
-| Replace Conditional with Polymorphism | Use polymorphism instead of switch/if |
-| Replace Magic Number with Constant | Named constants |
-| Decompose Conditional | Break complex conditions |
-| Consolidate Conditional | Combine duplicate conditions |
-| Replace Nested Conditional with Guard Clauses | Early returns |
-| Introduce Null Object | Eliminate null checks |
-| Replace Type Code with Class/Enum | Strong typing |
-| Replace Inheritance with Delegation | Composition over inheritance |
diff --git a/.github/skills/reviewer-protocol/SKILL.md b/.github/skills/reviewer-protocol/SKILL.md
deleted file mode 100644
index 5d589105..00000000
--- a/.github/skills/reviewer-protocol/SKILL.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-name: "reviewer-protocol"
-description: "Reviewer rejection workflow and strict lockout semantics"
-domain: "orchestration"
-confidence: "high"
-source: "extracted"
----
-
-## Context
-
-When a team member has a **Reviewer** role (e.g., Tester, Code Reviewer, Lead), they may approve or reject work from other agents. On rejection, the coordinator enforces strict lockout rules to ensure the original author does NOT self-revise. This prevents defensive feedback loops and ensures independent review.
-
-## Patterns
-
-### Reviewer Rejection Protocol
-
-When a team member has a **Reviewer** role:
-
-- Reviewers may **approve** or **reject** work from other agents.
-- On **rejection**, the Reviewer may choose ONE of:
- 1. **Reassign:** Require a *different* agent to do the revision (not the original author).
- 2. **Escalate:** Require a *new* agent be spawned with specific expertise.
-- The Coordinator MUST enforce this. If the Reviewer says "someone else should fix this," the original agent does NOT get to self-revise.
-- If the Reviewer approves, work proceeds normally.
-
-### Strict Lockout Semantics
-
-When an artifact is **rejected** by a Reviewer:
-
-1. **The original author is locked out.** They may NOT produce the next version of that artifact. No exceptions.
-2. **A different agent MUST own the revision.** The Coordinator selects the revision author based on the Reviewer's recommendation (reassign or escalate).
-3. **The Coordinator enforces this mechanically.** Before spawning a revision agent, the Coordinator MUST verify that the selected agent is NOT the original author. If the Reviewer names the original author as the fix agent, the Coordinator MUST refuse and ask the Reviewer to name a different agent.
-4. **The locked-out author may NOT contribute to the revision** in any form β not as a co-author, advisor, or pair. The revision must be independently produced.
-5. **Lockout scope:** The lockout applies to the specific artifact that was rejected. The original author may still work on other unrelated artifacts.
-6. **Lockout duration:** The lockout persists for that revision cycle. If the revision is also rejected, the same rule applies again β the revision author is now also locked out, and a third agent must revise.
-7. **Deadlock handling:** If all eligible agents have been locked out of an artifact, the Coordinator MUST escalate to the user rather than re-admitting a locked-out author.
-
-## Examples
-
-**Example 1: Reassign after rejection**
-1. Fenster writes authentication module
-2. Hockney (Tester) reviews β rejects: "Error handling is missing. Verbal should fix this."
-3. Coordinator: Fenster is now locked out of this artifact
-4. Coordinator spawns Verbal to revise the authentication module
-5. Verbal produces v2
-6. Hockney reviews v2 β approves
-7. Lockout clears for next artifact
-
-**Example 2: Escalate for expertise**
-1. Edie writes TypeScript config
-2. Keaton (Lead) reviews β rejects: "Need someone with deeper TS knowledge. Escalate."
-3. Coordinator: Edie is now locked out
-4. Coordinator spawns new agent (or existing TS expert) to revise
-5. New agent produces v2
-6. Keaton reviews v2
-
-**Example 3: Deadlock handling**
-1. Fenster writes module β rejected
-2. Verbal revises β rejected
-3. Hockney revises β rejected
-4. All 3 eligible agents are now locked out
-5. Coordinator: "All eligible agents have been locked out. Escalating to user: [artifact details]"
-
-**Example 4: Reviewer accidentally names original author**
-1. Fenster writes module β rejected
-2. Hockney says: "Fenster should fix the error handling"
-3. Coordinator: "Fenster is locked out as the original author. Please name a different agent."
-4. Hockney: "Verbal, then"
-5. Coordinator spawns Verbal
-
-## Anti-Patterns
-
-- β Allowing the original author to self-revise after rejection
-- β Treating the locked-out author as an "advisor" or "co-author" on the revision
-- β Re-admitting a locked-out author when deadlock occurs (must escalate to user)
-- β Applying lockout across unrelated artifacts (scope is per-artifact)
-- β Accepting the Reviewer's assignment when they name the original author (must refuse and ask for a different agent)
-- β Clearing lockout before the revision is approved (lockout persists through revision cycle)
-- β Skipping verification that the revision agent is not the original author
diff --git a/.github/skills/session-recovery/SKILL.md b/.github/skills/session-recovery/SKILL.md
deleted file mode 100644
index 9ce40a6b..00000000
--- a/.github/skills/session-recovery/SKILL.md
+++ /dev/null
@@ -1,155 +0,0 @@
----
-name: "session-recovery"
-description: "Find and resume interrupted Copilot CLI sessions using session_store queries"
-domain: "workflow-recovery"
-confidence: "high"
-source: "earned"
-tools:
- - name: "sql"
- description: "Query session_store database for past session history"
- when: "Always β session_store is the source of truth for session history"
----
-
-## Context
-
-Agents run in Copilot CLI sessions that can be interrupted β terminal crashes, network drops, machine restarts, or accidental window closes. When this happens, in-progress work may be left in a partially-completed state: branches with uncommitted changes, issues marked in-progress with no active agent, or checkpoints that were never finalized.
-
-Copilot CLI stores session history in a SQLite database called `session_store` (read-only, accessed via the `sql` tool with `database: "session_store"`). This skill teaches agents how to query that store to detect interrupted sessions and resume work.
-
-## Patterns
-
-### 1. Find Recent Sessions
-
-Query the `sessions` table filtered by time window. Include the last checkpoint to understand where the session stopped:
-
-```sql
-SELECT
- s.id,
- s.summary,
- s.cwd,
- s.branch,
- s.updated_at,
- (SELECT title FROM checkpoints
- WHERE session_id = s.id
- ORDER BY checkpoint_number DESC LIMIT 1) AS last_checkpoint
-FROM sessions s
-WHERE s.updated_at >= datetime('now', '-24 hours')
-ORDER BY s.updated_at DESC;
-```
-
-### 2. Filter Out Automated Sessions
-
-Automated agents (monitors, keep-alive, heartbeat) create high-volume sessions that obscure human-initiated work. Exclude them:
-
-```sql
-SELECT s.id, s.summary, s.cwd, s.updated_at,
- (SELECT title FROM checkpoints
- WHERE session_id = s.id
- ORDER BY checkpoint_number DESC LIMIT 1) AS last_checkpoint
-FROM sessions s
-WHERE s.updated_at >= datetime('now', '-24 hours')
- AND s.id NOT IN (
- SELECT DISTINCT t.session_id FROM turns t
- WHERE t.turn_index = 0
- AND (LOWER(t.user_message) LIKE '%keep-alive%'
- OR LOWER(t.user_message) LIKE '%heartbeat%')
- )
-ORDER BY s.updated_at DESC;
-```
-
-### 3. Search by Topic (FTS5)
-
-Use the `search_index` FTS5 table for keyword search. Expand queries with synonyms since this is keyword-based, not semantic:
-
-```sql
-SELECT DISTINCT s.id, s.summary, s.cwd, s.updated_at
-FROM search_index si
-JOIN sessions s ON si.session_id = s.id
-WHERE search_index MATCH 'auth OR login OR token OR JWT'
- AND s.updated_at >= datetime('now', '-48 hours')
-ORDER BY s.updated_at DESC
-LIMIT 10;
-```
-
-### 4. Search by Working Directory
-
-```sql
-SELECT s.id, s.summary, s.updated_at,
- (SELECT title FROM checkpoints
- WHERE session_id = s.id
- ORDER BY checkpoint_number DESC LIMIT 1) AS last_checkpoint
-FROM sessions s
-WHERE s.cwd LIKE '%my-project%'
- AND s.updated_at >= datetime('now', '-48 hours')
-ORDER BY s.updated_at DESC;
-```
-
-### 5. Get Full Session Context Before Resuming
-
-Before resuming, inspect what the session was doing:
-
-```sql
--- Conversation turns
-SELECT turn_index, substr(user_message, 1, 200) AS ask, timestamp
-FROM turns WHERE session_id = 'SESSION_ID' ORDER BY turn_index;
-
--- Checkpoint progress
-SELECT checkpoint_number, title, overview
-FROM checkpoints WHERE session_id = 'SESSION_ID' ORDER BY checkpoint_number;
-
--- Files touched
-SELECT file_path, tool_name
-FROM session_files WHERE session_id = 'SESSION_ID';
-
--- Linked PRs/issues/commits
-SELECT ref_type, ref_value
-FROM session_refs WHERE session_id = 'SESSION_ID';
-```
-
-### 6. Detect Orphaned Issue Work
-
-Find sessions that were working on issues but may not have completed:
-
-```sql
-SELECT DISTINCT s.id, s.branch, s.summary, s.updated_at,
- sr.ref_type, sr.ref_value
-FROM sessions s
-JOIN session_refs sr ON s.id = sr.session_id
-WHERE sr.ref_type = 'issue'
- AND s.updated_at >= datetime('now', '-48 hours')
-ORDER BY s.updated_at DESC;
-```
-
-Cross-reference with `gh issue list --label "status:in-progress"` to find issues that are marked in-progress but have no active session.
-
-### 7. Resume a Session
-
-Once you have the session ID:
-
-```bash
-# Resume directly
-copilot --resume SESSION_ID
-```
-
-## Examples
-
-**Recovering from a crash during PR creation:**
-1. Query recent sessions filtered by branch name
-2. Find the session that was working on the PR
-3. Check its last checkpoint β was the code committed? Was the PR created?
-4. Resume or manually complete the remaining steps
-
-**Finding yesterday's work on a feature:**
-1. Use FTS5 search with feature keywords
-2. Filter to the relevant working directory
-3. Review checkpoint progress to see how far the session got
-4. Resume if work remains, or start fresh with the context
-
-## Anti-Patterns
-
-- β Searching by partial session IDs β always use full UUIDs
-- β Resuming sessions that completed successfully β they have no pending work
-- β Using `MATCH` with special characters without escaping β wrap paths in double quotes
-- β Skipping the automated-session filter β high-volume automated sessions will flood results
-- β Assuming FTS5 is semantic search β it's keyword-based; always expand queries with synonyms
-- β Ignoring checkpoint data β checkpoints show exactly where the session stopped
diff --git a/.github/skills/test-discipline/SKILL.md b/.github/skills/test-discipline/SKILL.md
deleted file mode 100644
index d222bed5..00000000
--- a/.github/skills/test-discipline/SKILL.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-name: "test-discipline"
-description: "Update tests when changing APIs β no exceptions"
-domain: "quality"
-confidence: "high"
-source: "earned (Fenster/Hockney incident, test assertion sync violations)"
----
-
-## Context
-
-When APIs or public interfaces change, tests must be updated in the same commit. When test assertions reference file counts or expected arrays, they must be kept in sync with disk reality. Stale tests block CI for other contributors.
-
-## Patterns
-
-- **API changes β test updates (same commit):** If you change a function signature, public interface, or exported API, update the corresponding tests before committing
-- **Test assertions β disk reality:** When test files contain expected counts (e.g., `EXPECTED_FEATURES`, `EXPECTED_SCENARIOS`), they must match the actual files on disk
-- **Add files β update assertions:** When adding docs pages, features, or any counted resource, update the test assertion array in the same commit
-- **CI failures β check assertions first:** Before debugging complex failures, verify test assertion arrays match filesystem state
-
-## Examples
-
-β **Correct:**
-- Changed auth API signature β updated auth.test.ts in same commit
-- Added `distributed-mesh.md` to features/ β added `'distributed-mesh'` to EXPECTED_FEATURES array
-- Deleted two scenario files β removed entries from EXPECTED_SCENARIOS
-
-β **Incorrect:**
-- Changed spawn parameters β committed without updating casting.test.ts (CI breaks for next person)
-- Added `built-in-roles.md` β left EXPECTED_FEATURES at old count (PR blocked)
-- Test says "expected 7 files" but disk has 25 (assertion staleness)
-
-## Anti-Patterns
-
-- Committing API changes without test updates ("I'll fix tests later")
-- Treating test assertion arrays as static (they evolve with content)
-- Assuming CI passing means coverage is correct (stale assertions can pass while being wrong)
-- Leaving gaps for other agents to discover
diff --git a/.markdownlint-cli2.jsonc b/.markdownlint-cli2.jsonc
index fcdb3847..a4e0ea55 100644
--- a/.markdownlint-cli2.jsonc
+++ b/.markdownlint-cli2.jsonc
@@ -14,12 +14,6 @@
"**/obj/**",
"**/.pytest_cache/**",
"team-docs/**",
- // Legacy Copilot guidance, never linted before: rewritten or removed by
- // the agent-guidance follow-up, which drops these ignores.
- ".github/copilot-instructions.md",
- ".github/instructions/**",
- ".github/prompts/**",
- ".github/skills/**",
// Generated by the release workflow from PR bodies.
"docs/blogs/**"
]
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..6ea29b37
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,82 @@
+# IssueTracker
+
+An issue tracker built as a Blazor Server app on .NET 10 and C# 14, with MongoDB for storage and Redis for caching,
+orchestrated by .NET Aspire. The files under `.github/instructions/` add detail for specific file types; where one of
+them disagrees with this file, this file wins.
+
+## Layout
+
+The solution is `IssueTracker.slnx`. It follows Clean Architecture, and dependencies point inward only:
+
+| Project | Layer | Holds |
+| --- | --- | --- |
+| `src/UI/IssueTracker.UI` | Presentation | Blazor Server pages (`Pages/`), components (`Components/`), layout (`Shared/`), DI registration (`Extensions/`) |
+| `src/Services/IssueTracker.Services` | Application | One service per aggregate (`Issue/`, `Comment/`, `Category/`, `Status/`, `User/`) and the repository interfaces they need (`PlugInRepositoryInterfaces/`) |
+| `src/CoreBusiness/IssueTracker.CoreBusiness` | Domain | Models (`IssueModel`, `CommentModel`, ...), their `Basic*Model` summaries, enums, and Bogus fakes |
+| `src/PlugIns/IssueTracker.PlugIns` | Infrastructure | MongoDB repositories (`DataAccess/`) and `MongoDbContextFactory` |
+| `src/ServiceDefaults` | Cross-cutting | Aspire service defaults, OpenTelemetry, health checks, `CacheService` |
+| `src/AppHost` | Orchestration | Starts MongoDB, Redis, and the UI |
+
+`tests/Architecture.Tests` checks part of this with NetArchTest: CoreBusiness doesn't depend on the UI or AppHost,
+nothing references AppHost, and ServiceDefaults has no cycles. The rest of the layering is convention, so keep to it.
+
+## How the pieces fit
+
+- The UI calls services only. It references `IssueTracker.PlugIns` for two things: `Extensions/` (the composition root)
+ registers the repositories, and `Helpers/MongoHealthCheck.cs` pings MongoDB for the health endpoint. Pages and
+ components never touch MongoDB or a repository.
+- Services depend on the repository interfaces in `PlugInRepositoryInterfaces/`; `IssueTracker.PlugIns` implements them.
+ Services cache reads in `IMemoryCache` (one minute for issues and comments, a day for categories and statuses).
+ New write paths must remove every cache entry they affect. Several existing ones don't yet, so reads can be stale
+ until the entry expires; #149 tracks fixing them. Redis backs the distributed cache that
+ `ServiceDefaults` registers (`CacheService`).
+- Authentication is Azure AD B2C through Microsoft.Identity.Web (`AzureAdB2C` configuration section), wired up in
+ `Extensions/AuthenticationService.cs`.
+- UI components come from Radzen.Blazor, styled with Bootstrap plus `wwwroot/css/site.css`.
+- Configuration comes from user secrets, environment variables (prefix `IssueTrackerUI_`), and Aspire's resource references.
+ Never put secrets in `appsettings*.json` or code.
+
+## Build, run and test
+
+```bash
+dotnet build IssueTracker.slnx -c Release -warnaserror # what CI and the pre-push gate run
+dotnet run --project src/AppHost # the whole app with MongoDB and Redis (needs Docker)
+dotnet test tests/ -c Release # one test project
+scripts/gate.sh # everything the pre-push hook checks
+```
+
+- The SDK is pinned in `global.json` to the 10.0.3xx band (`rollForward: latestPatch`). SDK 10.0.4xx doesn't compile the
+ Razor pages yet.
+- Package versions live in `Directory.Packages.props` (Central Package Management). A `PackageReference` has no `Version`.
+- Builds treat warnings as errors. A `NoWarn` needs a comment saying why and when it goes away.
+- Run test projects one at a time. At the `.slnx` level the test runner can report `Zero tests ran`.
+- Integration tests (`Integration.Tests`, `IssueTracker.PlugIns.Tests.Integration`) and `AppHost.Tests` start containers
+ with Testcontainers or Aspire, so they need Docker.
+
+## Tests
+
+- xUnit v2 on VSTest, with FluentAssertions, NSubstitute or Moq, and Bogus fakes from CoreBusiness.
+- Components are tested with bUnit. The existing tests still use bUnit's obsolete `TestContext`, pending a migration;
+ new tests use its replacement, `BunitContext`.
+- Every test has `// Arrange`, `// Act` and `// Assert` markers. Test names read as
+ `Method_With_Condition_Should_Result_Test`, as in `CreateCategory_With_Valid_Values_Should_Return_Test`.
+- Write the failing test first for new behaviour and bug fixes.
+- CI fails below 60% line coverage.
+
+## Code style
+
+`.editorconfig` is authoritative: tabs, file-scoped namespaces, explicit types rather than `var`, and `System` usings
+first. Every `.cs` file starts with the repository's copyright header block, and public members have XML doc comments.
+
+## Workflow
+
+- Branches: `squad/{issue}-{slug}`, `sprint/{n}-{slug}`, `feature/{issue}-{slug}`, `hotfix/{issue}-{slug}` or
+ `chore/{slug}`, each in its own worktree under `../IssueTracker-worktrees/`. PRs target `main`.
+- Turn on the hooks once per clone: `git config core.hooksPath .github/hooks`. Pre-commit lints staged Markdown;
+ pre-push checks the branch name and runs `scripts/gate.sh`.
+- Commit messages follow `.github/instructions/git-commit-instructions.md`.
+- `Build Solution` and `Test Suite` are required checks. `pr-automerge.yml` squash-merges a PR once they pass, Copilot has
+ reviewed it and every thread is resolved; open a draft PR to hold one back.
+- Each PR merged to `main` gets a release (patch by default; label `semver:minor` or `semver:major` to bump more) and
+ a follow-up PR with its blog post under `docs/blogs/`. PRs with `[skip-release]` in the title, such as those blog
+ PRs and metrics refreshes, don't release.
diff --git a/tests/IssueTracker.UI.Tests.Unit/IssueTracker.UI.Tests.Unit.csproj b/tests/IssueTracker.UI.Tests.Unit/IssueTracker.UI.Tests.Unit.csproj
index 18d44597..1b8d759a 100644
--- a/tests/IssueTracker.UI.Tests.Unit/IssueTracker.UI.Tests.Unit.csproj
+++ b/tests/IssueTracker.UI.Tests.Unit/IssueTracker.UI.Tests.Unit.csproj
@@ -4,8 +4,9 @@
enableenablefalse
-
+
$(NoWarn);CS0618;CS0067trueTrue