Significant updates to copilot instructions infrastructure.

Docker image build fieldworks
Don't allow forceable resetting of git-worktrees

Author: johnml1135

.dockerignore

@@ -0,0 +1,87 @@
+# Build outputs
+Output/
+Obj/
+bin/
+obj/
+*.user
+
+# Test results
+TestResults/
+
+# NuGet packages
+packages/
+.nuget/
+
+# Git
+.git/
+.github/
+.gitignore
+.gitattributes
+
+# Visual Studio
+.vs/
+*.suo
+*.sln.docstates
+
+# Documentation and analysis files
+*.md
+!ReadMe.md
+COPILOT.md
+*.prompt.md
+BUILD_CHALLENGES_ANALYSIS.md
+CLARIFICATIONS-NEEDED.md
+COMPREHENSIVE_COMMIT_ANALYSIS.md
+CONVERGENCE-FRAMEWORK.md
+CONVERGENCE-STATUS.md
+DEEP_COMMIT_ANALYSIS.md
+DLL_MODERNIZATION_PLAN.md
+LEGACY_REMOVAL_SUMMARY.md
+MIGRATION_DOCS_INDEX.md
+MIGRATION_FIXES_SUMMARY.md
+MIGRATION_SUMMARY_BY_PHASE.md
+NON_SDK_ELIMINATION.md
+NUNIT4_CONVERSION_SUMMARY.md
+PACKAGE_MANAGEMENT_QUICKSTART.md
+RHINOMOCKS_TO_MOQ_MIGRATION.md
+SDK-MIGRATION.md
+TRAVERSAL_SDK_IMPLEMENTATION.md
+
+# Test projects and data
+TestLangProj/
+specs/
+
+# Vagrant
+vagrant/
+
+# Python scripts (not needed in container)
+*.py
+
+# Docs
+Docs/
+
+# Resources (will copy specific ones if needed)
+resources/
+
+# Scripts (not needed for Docker build)
+scripts/
+
+# FLExInstaller (not building installer in container)
+FLExInstaller/
+
+# Sample/test code
+Samples/
+
+# Large binary files
+*.exe
+!DistFiles/**/*.exe
+*.dll
+!DistFiles/**/*.dll
+*.pdb
+*.lib
+*.exp
+
+# Temporary files
+*.tmp
+*.log
+*.bak
+*~

.github/copilot-instructions.md

@@ -0,0 +1,48 @@
+---
+applyTo: "Src/AppCore/**"
+name: "appcore.instructions"
+description: "Auto-generated concise instructions from COPILOT.md for AppCore"
+---
+
+# AppCore (Concise)
+
+## Purpose & Scope
+Summarized key points from COPILOT.md
+
+## Key Rules
+- **AfGfx** class (AfGfx.h/cpp): Static utility methods for Windows GDI operations
+- `LoadSysColorBitmap()`: Loads system-colored bitmaps from resources
+- `FillSolidRect()`: Fills rectangle with solid color using palette
+- `InvertRect()`, `CreateSolidBrush()`: Rectangle inversion and brush creation
+- `SetBkColor()`, `SetTextColor()`: Palette-aware color setting
+- `DrawBitMap()`: Bitmap drawing with source/dest rectangles
+
+## Example (from summary)
+
+---
+last-reviewed: 2025-10-31
+last-reviewed-tree: d533214a333e8de29f0eaa52ed6bbffd80815cfb0f1f3fac15cd08b96aafb15e
+status: draft
+---
+
+# AppCore COPILOT summary
+
+## Purpose
+Provides Windows GDI wrapper classes and graphics utilities for FieldWorks native applications. Includes device context management (SmartDc), GDI object wrappers (FontWrap, BrushWrap, PenWrap, RgnWrap), color palette support (ColorTable with 40 predefined colors, SmartPalette), and writing system style inheritance utilities (FwStyledText namespace). These utilities abstract Windows graphics APIs and provide consistent rendering behavior across FieldWorks.
+
+## Architecture
+C++ native header-only library. Headers and implementation files are designed to be included into consumer projects (primarily views) via include search paths rather than built as a standalone library. The code provides three major areas: graphics primitives and GDI abstractions (AfGfx, AfGdi), styled text property management (FwStyledText namespace), and color management (ColorTable global singleton).
+
+## Key Components
+- **AfGfx** class (AfGfx.h/cpp): Static utility methods for Windows GDI operations
+  - `LoadSysColorBitmap()`: Loads system-colored bitmaps from resources
+  - `FillSolidRect()`: Fills rectangle with solid color using palette
+  - `InvertRect()`, `CreateSolidBrush()`: Rectangle inversion and brush creation
+  - `SetBkColor()`, `SetTextColor()`: Palette-aware color setting
+  - `DrawBitMap()`: Bitmap drawing with source/dest rectangles
+  - `EnsureVisibleRect()`: Validates/adjusts rectangle visibility
+- **AfGdi** class (AfGfx.h): Tracked wrappers for GDI resource creation/destruction with leak detection
+  - Device context tracking: `CreateDC()`, `CreateCompatibleDC()`, `DeleteDC()`, `GetDC()`, `ReleaseDC()`
+  - Font tracking: `CreateFont()`, `CreateFontIndirect()`, `DeleteObject()` with s_cFonts counter
+  - GDI object tracking: `CreatePen()`, `CreateBrush()`, `SelectObject()` with debug counters
+  - Debug flags: `s_fSh

.github/instructions/appcore.instructions.md

@@ -1,9 +1,13 @@
 ---
 applyTo: "**/*"
+name: "build.instructions"
 description: "FieldWorks build guidelines and inner-loop tips"
 ---
 # Build guidelines and inner-loop tips
 
+## Purpose & Scope
+This file describes the build system and inner-loop tips for developers working on FieldWorks. Use it for top-level build instructions, not for project-specific guidance.
+
 ## Quick Start
 
 FieldWorks uses the **MSBuild Traversal SDK** for declarative build ordering. All builds use `FieldWorks.proj`.
@@ -63,10 +67,11 @@ Error: Cannot generate Views.cs without native artifacts.
 Run: msbuild Build\Src\NativeBuild\NativeBuild.csproj
 ```
 
-## Context loading
-- Always initialize the environment when using scripts: `source ./environ`.
-- The build system automatically sets up VS Developer Environment if needed.
-- Environment variables (`fwrt`, `Platform`, etc.) are set by `SetupInclude.targets`.
+## Developer environment setup
+
+- On Windows: Use `.\build.ps1` (automatically sets up VS Developer Environment) or open a Developer Command Prompt for Visual Studio before running manual `msbuild` commands.
+- On Linux/macOS: Use `./build.sh` and ensure `msbuild`, `dotnet`, and native build tools are installed.
+- Environment variables (`fwrt`, `Platform`, etc.) are set by `SetupInclude.targets` during build.
 
 ## Deterministic requirements
 

.github/instructions/build.instructions.md

@@ -0,0 +1,14 @@
+---
+description: 'C++ project configuration and package management'
+applyTo: '**/*.cmake, **/CMakeLists.txt, **/*.cpp, **/*.h, **/*.hpp'
+name: 'cmake-vcpkg.instructions'
+---
+
+## Purpose & Scope
+This file captures vcpkg and CMake practices for the native C++ projects and helps Copilot make sensible recommendations.
+
+This project uses vcpkg in manifest mode. Please keep this in mind when giving vcpkg suggestions. Do not provide suggestions like vcpkg install library, as they will not work as expected.
+Prefer setting cache variables and other types of things through CMakePresets.json if possible.
+Give information about any CMake Policies that might affect CMake variables that are suggested or mentioned.
+This project needs to be cross-platform and cross-compiler for MSVC, Clang, and GCC.
+When providing OpenCV samples that use the file system to read files, please always use absolute file paths rather than file names, or relative file paths. For example, use `video.open("C:/project/file.mp4")`, not `video.open("file.mp4")`.

.github/instructions/cmake-vcpkg.instructions.md

@@ -0,0 +1,20 @@
+---
+applyTo: "Src/Common/**"
+name: "common.instructions"
+description: "Key conventions and integration points for the Common project." 
+---
+
+# Common Library Guidelines
+
+## Purpose & Scope
+- Document public utility contracts, expected threading model, and test patterns for `Src/Common`.
+
+## Conventions
+- Keep public API surface minimal and stable; add unit tests for contract changes.
+- Avoid adding heavy dependencies to Common; favor small, well-defined helper functions.
+
+## Examples
+```csharp
+// Good: small, well-defined helper public API
+public static string NormalizePath(string path) => Path.GetFullPath(path);
+```

.github/instructions/common.instructions.md

@@ -0,0 +1,118 @@
+---
+applyTo: '**/*.cs'
+name: 'csharp.instructions'
+description: 'Guidelines for building C# applications'
+---
+
+# C# Development
+
+## Purpose & Scope
+Provide concise C# conventions and style rules to keep code consistent across the repository.
+
+## C# Instructions
+- Always use the latest version C#, currently C# 14 features.
+- Write clear and concise comments for each function.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+
+## Naming Conventions
+
+- 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).
+
+## Formatting
+
+- Apply code-formatting style defined in `.editorconfig`.
+- Prefer file-scoped namespace declarations and single-line using directives.
+- Insert a newline before the opening curly brace of any code block (e.g., after `if`, `for`, `while`, `foreach`, `using`, `try`, etc.).
+- Ensure that the final return statement of a method is on its own line.
+- Use pattern matching and switch expressions wherever possible.
+- Use `nameof` instead of string literals when referring to member names.
+- Ensure that XML doc comments are created for any public APIs. When applicable, include `<example>` and `<code>` documentation in the comments.
+
+## Project Setup and Structure
+
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 10 including environment-specific settings.
+
+## Nullable Reference Types
+
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
+
+## Data Access Patterns
+
+- Guide the implementation of a data access layer using Entity Framework Core.
+- Explain different options (SQL Server, SQLite, In-Memory) for development and production.
+- Demonstrate repository pattern implementation and when it's beneficial.
+- Show how to implement database migrations and data seeding.
+- Explain efficient query patterns to avoid common performance issues.
+
+## Authentication and Authorization
+
+- Guide users through implementing authentication using JWT Bearer tokens.
+- Explain OAuth 2.0 and OpenID Connect concepts as they relate to ASP.NET Core.
+- Show how to implement role-based and policy-based authorization.
+- Demonstrate integration with Microsoft Entra ID (formerly Azure AD).
+- Explain how to secure both controller-based and Minimal APIs consistently.
+
+## Validation and Error Handling
+
+- Guide the implementation of model validation using data annotations and FluentValidation.
+- Explain the validation pipeline and how to customize validation responses.
+- Demonstrate a global exception handling strategy using middleware.
+- Show how to create consistent error responses across the API.
+- Explain problem details (RFC 7807) implementation for standardized error responses.
+
+## API Versioning and Documentation
+
+- Guide users through implementing and explaining API versioning strategies.
+- Demonstrate Swagger/OpenAPI implementation with proper documentation.
+- Show how to document endpoints, parameters, responses, and authentication.
+- Explain versioning in both controller-based and Minimal APIs.
+- Guide users on creating meaningful API documentation that helps consumers.
+
+## Logging and Monitoring
+
+- Guide the implementation of structured logging using Serilog or other providers.
+- Explain the logging levels and when to use each.
+- Demonstrate integration with Application Insights for telemetry collection.
+- Show how to implement custom telemetry and correlation IDs for request tracking.
+- Explain how to monitor API performance, errors, and usage patterns.
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.
+
+## Deployment and DevOps
+
+- Guide users through containerizing their API using .NET's built-in container support (`dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer`).
+- Explain the differences between manual Dockerfile creation and .NET's container publishing features.
+- Explain CI/CD pipelines for NET applications.
+- Demonstrate deployment to Azure App Service, Azure Container Apps, or other hosting options.
+- Show how to implement health checks and readiness probes.
+- Explain environment-specific configurations for different deployment stages.

.github/instructions/csharp.instructions.md

@@ -0,0 +1,45 @@
+---
+applyTo: "Src/Common/FieldWorks/**"
+name: "fieldworks.instructions"
+description: "Auto-generated concise instructions from COPILOT.md for FieldWorks"
+---
+
+# FieldWorks (Concise)
+
+## Purpose & Scope
+Summarized key points from COPILOT.md
+
+## Key Rules
+- **FieldWorks** class (FieldWorks.cs): Main application singleton
+- Manages application lifecycle and FwApp instances
+- Handles project selection, opening, and closing
+- Coordinates window creation and management
+- Provides LcmCache access
+- Main entry point: OutputType=WinExe
+
+## Example (from summary)
+
+---
+last-reviewed: 2025-10-31
+last-reviewed-tree: 02736fd2ef91849ac9b0a8f07f2043ff2e3099bbab520031f8b27b4fe42a33cf
+status: draft
+---
+
+# FieldWorks COPILOT summary
+
+## Purpose
+Core FieldWorks-specific application infrastructure and utilities providing fundamental application services. Includes project management (FieldWorksManager interface, ProjectId for project identification), settings management (FwRestoreProjectSettings for backup restoration), application startup coordination (WelcomeToFieldWorksDlg, FieldWorks main class), busy state handling (ApplicationBusyDialog), Windows installer querying (WindowsInstallerQuery), remote request handling (RemoteRequest), lexical service provider integration (ILexicalProvider, LexicalServiceProvider), and Phonology Assistant integration objects (PaObjects/ namespace). Central to coordinating application lifecycle, managing shared resources, and enabling interoperability across FieldWorks applications.
+
+## Architecture
+C# Windows executable (WinExe) targeting .NET Framework 4.8.x. Main entry point for FieldWorks application launcher. Contains FieldWorks singleton class managing application lifecycle, project opening/closing, and window management. Includes three specialized namespaces: LexicalProvider/ for lexicon service integration, PaObjects/ for Phonology Assistant data transfer objects, and main SIL.FieldWorks namespace for core infrastructure. Test project (FieldWorksTests) provides unit tests for project ID, PA objects, and welcome dialog.
+
+## Key Components
+- **FieldWorks** class (FieldWorks.cs): Main application singleton
+  - Manages application lifecycle and FwApp instances
+  - Handles project selection, opening, and closing
+  - Coordinates window creation and management
+  - Provides LcmCache access
+  - Main entry point: OutputType=WinExe
+- **FieldWorksManager** class (FieldWorksManager.cs): IFieldWorksManager implementation
+  - Pass-through facade ensuring single FieldWorks instance per process
+  - `Cache` propert