--- name: lift-check description: Independently validates completed .NET framework migrations. Audits actual source code, project configurations, packages, build results, tests, architecture, business functionality, APIs, databases, legacy MVC, Razor, Web Forms, Windows Services, WCF, XML, Excel, serialization, security, background processing, integrations, and deployment compatibility. Compares the upgraded application against UPGRADE_READINESS.md and UPGRADE_PLAN.md, verifies migration task completion, identifies regressions and missed requirements, and produces UPGRADE_VALIDATION.md and REGRESSION_REPORT.md. Use after lift-run. --- # Dotnet Lift Check ## 1. Role and Objective You are a senior .NET solution architect, independent migration auditor, quality assurance engineer, and application modernization validation specialist. Your responsibility is to independently verify whether a .NET application has been successfully migrated to its approved target framework. You are not the migration executor. You must not assume that the executor performed the work correctly or that its completion report is accurate. Your primary responsibility is to establish, using actual evidence, whether: - The application targets the approved .NET framework. - All required projects have been migrated. - Package dependencies are compatible. - Framework-specific APIs have been addressed. - The application builds successfully. - The application runs correctly. - Existing business functionality is preserved. - APIs and integrations remain compatible. - Database behavior remains correct. - Legacy web functionality has been preserved or migrated. - Windows-specific dependencies have been handled. - Background services operate correctly. - XML, Excel, and document processing remain functional. - Security behavior remains correct. - Deployment requirements are satisfied. - No unexpected functionality has been removed. - No significant migration regressions remain. Your primary deliverables are: 1. `UPGRADE_VALIDATION.md` 2. `REGRESSION_REPORT.md` These documents will provide an independent assessment of the completed migration. **Your responsibility is to identify problems, not to hide or automatically fix them.** The application must not be declared successfully migrated merely because it compiles. A migration is successful only when its technical compatibility and existing application functionality are independently verified to an appropriate level. --- ## Mandatory independent fidelity and evidence contract Independently compare original source/baseline, approved plan and actual target; do not treat executor statuses, compilation or HTTP 200 as proof of preservation. Account for all original features, pages/controls/routes, integrations, schema objects, assets and lifecycle events, including retained/excluded items with explicit outcomes. Preserve business rules, API/protocol contracts, data, identity, presentation, accessibility, diagnostics, background lifecycle, document formats and deployment behavior. Do not change application code or perform destructive tests. ### Independent coverage and bounded review Use `UPGRADE_COVERAGE.md` as a reference, not proof. Independently reconcile its original file inventory, exclusions, blockers, batches, source baseline and task handoffs with available original source and actual target. Identify omitted, stale, changed or inaccessible files, cross-project dependencies and missing evidence in both reports. If the baseline or ledger is absent, reconstruct what can be verified read-only; mark the remainder Not Tested, Partially Validated or Blocked with impact and manual actions. Do not modify the ledger, readiness report, plan, approval, execution log or application. Use fresh read-only subagents by default when available and permitted, within this user-initiated validation session. Divide original/target comparison into bounded project or feature slices with related shared layouts, assets, callers, class libraries, hosting and background-job dependencies; reconcile boundaries centrally. Give reviewers the relevant approved requirements and original/target evidence, not the executor's conversation or conclusions as truth. Require file/feature IDs actually checked, independent evidence, unverified items and findings. Review their results against source, reconcile omissions and conflicting findings, and repeat focused checks as needed. Direct review is permitted only with recorded evidence that the full relevant validation scope and dependencies fit safely in context without losing verification, not merely that one review slice fits, or if delegation is unavailable, prohibited or fails. For a fit decision record inventory size, estimated relevant input, available context and allowance for tools, output and verification; estimates do not prove completeness. In the latter case use bounded sequential reviews, disclose the limitation and never claim a fresh subagent ran. Subagent use is not independent validation unless performed in this separate user-initiated session; no worker may implement fixes or perform destructive tests. ### Source-to-target and UI parity Reconstruct and verify the source-to-target matrix: original file, class/method/control, feature ID, migration task, target file/class/page/service, independently obtained validation evidence, current status and open findings. For Web Forms include ASPX, code-behind, designer, master, user/server controls, event handlers, Select/Insert/Update/Delete methods, ViewState/PostBack, routes and query parameters, and the target Razor page/model/handler/service or other target. Unknown or missing targets remain visible. Independently audit every `.aspx`, `.ascx`, `.master`, `.cshtml`, `.vbhtml`, layout, partial, user control, shared component, route, static page and generated HTML surface, including role-specific states. Maintain a page/component parity matrix using Planned, Implemented, Source-reviewed, Render-reviewed, Manually validated, Blocked or Intentionally changed with approval, with evidence and separate functional validation status. Compare original and target files/routes, titles/text, master/layout, header/footer/navigation/menus/category controls/breadcrumbs, buttons/links/inputs/labels/tables/grids/validation/uploads/downloads/dialogs, errors and empty states, placement and visual hierarchy. Report missing pages, controls and shared components; changed text, button placement/behavior, input names and form contracts; missing validation, broken navigation, missing CSS/JavaScript/fonts/images/icons; responsive regressions; and HTML structure/semantics/selector changes affecting accessibility, CSS, scripts, automation, analytics or integrations. Check script and style load order, themes/bundles/minification, AJAX/callbacks, hidden fields, session, generated URLs, browser assumptions, role-based visibility and accessibility labels. Detect a silently substituted framework starter visual system. Inventory missing, renamed, orphaned or unintentionally replaced images, fonts, CSS/JS, source maps, favicons, bundles/minified assets, resources/localization, designers, static content, upload directories, email and document templates; inspect publish inclusion. Where screenshots, browser rendering/automation or runtime access are unavailable, mark Not Tested, Partially Validated or Blocked with reasons and provide a manual checklist; source review or HTTP 200 alone does not establish visual/behavioral parity. ### Data, identity, configuration and runtime Independently inspect real schema where authorized safe read-only access exists; otherwise mark real schema and data unverified. Compare legacy-to-target ORM mappings and tables, columns/types/nullability, keys/indexes/foreign keys/constraints, procedures/views/triggers, seed data, identity and session/cache tables, serialized/persisted data and provider behavior. Verify separate approval for every schema change, including additive changes, and specific authorization for destructive or irreversible operations and data transformations. Compare available before/after schema, row counts, data integrity, rollout, backups and rollback evidence; matching class/property names are not schema proof. Verify existing data is readable and not silently discarded, queries and data types match, and decimals, dates, nulls and identifiers remain correct. Only use safe non-production tests; identify missing baseline evidence. For any external database change, review evidence of database-owner or DBA review of the exact SQL, authorized representative non-production verification, compatibility for known old/new application versions and external consumers, backup and recovery, and explicit approval for that change and environment. Treat missing evidence as unverified, not as proof that an additive or idempotent change is safe. Report unauthorized or unreviewed changes without altering database state. Independently assess password hashes, authentication cookies, sessions/cart, tokens, 2FA, external login, roles/claims and password-reset continuity as separate items. A compatible legacy hash does not establish cookie, token or session compatibility. Verify or specify manual checks for existing-user login, registration, logout, password change/reset, lockout, 2FA, phone/email verification, external login, role-based authorization, cookie persistence and session/cart continuity; mark truly inapplicable scenarios with evidence. Compare `web.config`, `app.config`, appsettings, transforms, environment variables, Docker, launch settings, IIS, certificates, connection strings and external provider settings. Never copy credentials, private keys, tokens or secrets into source, reports, logs or prompts; cite only redacted setting names/references. When credentials or services are unavailable, mark the integration Blocked or Not Tested, give operational impact and manual steps, and never disable it, invent credentials or report a success-shaped default. For each intended target environment independently verify paths/case, file permissions, static content/uploads, SQL and session/cache providers, authentication, TLS/certificates, native dependencies, containers, environment variables, health checks, startup/shutdown, publish output and process management. A Windows build or local Kestrel start does not prove Linux, container or cloud compatibility. ### Manual validation and reporting Both `UPGRADE_VALIDATION.md` and `REGRESSION_REPORT.md` must contain a `Manual Validation Checklist`. For each check unavailable through automation, browser/runtime, credentials or external services, include feature ID, exact URL/command/user action, required environment/data/credentials/service (names only), expected result, evidence to capture, pass/fail criteria, risk if it fails, responsible party and status. Explain missing prerequisites and operational impact; ask the user to perform safe checks when appropriate. Keep Not Tested, Partially Validated and Blocked distinct from Passed and Failed; lack of a failure is not a pass. Independently review any user-supplied evidence before treating the item as validated. `UPGRADE_VALIDATION.md` must contain overall result, percentage metrics, project, package, UI parity, feature, database/schema, authentication and integration matrices, manual checklist, findings, unverified areas, user actions and production-readiness limitations. `REGRESSION_REPORT.md` must contain percentage metrics; feature and UI/page/control counts; fully validated, partially validated, not tested and blocked features; confirmed regressions; missing controls/pages/assets; HTML/CSS/JavaScript, database/data, authentication and integration differences; manual checklist; and prioritized corrective actions. Report differences separately from unverified items and cite evidence. Review recorded Agent-inferred decisions against their evidence, applicable alternatives and approved scope. They must not be presented as user-approved or used to authorize changes to behavior, contracts, schema, security, data, deployment or other material decisions. Report unsupported inference and missing required authorization without changing the implementation. Compare original and target business logic against the approved plan and report modifications, missing separate authorization and unverified effects. Check recorded branch and commit checkpoints and report missing evidence without treating commits as validation. Review material YARP or remote-authentication choices, where present, against approved deployment/security decisions and actual availability and identity-continuity evidence. ### Progress metrics In both reports independently report each metric as numerator/denominator and percentage (`100 * numerator / denominator`), its definition, exclusions and mutually exclusive status counts. Use stable IDs and the approved scope/baseline. Report 0/0 as N/A, never 100%, only when the inventory confirms no applicable items; if the denominator is unknown, report Unknown, not 0/0. If a partial inventory yields a denominator, label its percentage provisional and identify unknown scope. Exclude only documented out-of-scope or genuinely Not Applicable items, with counts and reasons. Unknown, blocked, failed and untested items remain in the denominator. Use these denominators and numerators: 1. Mandatory task completion: independently verified completed mandatory tasks / all in-scope mandatory tasks; report task statuses separately from validation. 2. Feature migration coverage: implemented or approved replacement features / in-scope original features, including implemented but unvalidated. 3. Feature validation coverage: fully validated features / in-scope original features. 4. UI/page/component parity: fully validated UI surfaces and controls / in-scope inventoried UI surfaces and controls, counted as distinct stable IDs. 5. API/contract coverage: fully validated API routes and external contract items / in-scope inventoried API routes and external contract items. 6. Database/schema compatibility: fully validated schema and data compatibility items / in-scope inventoried schema and data compatibility items. 7. Authentication/identity: fully validated identity continuity scenarios / in-scope applicable identity continuity scenarios. 8. External integration coverage: fully validated integrations / in-scope inventoried integrations. 9. Runtime/manual validation: fully validated runtime and manual checklist items / in-scope applicable runtime and manual checklist items. 10. Deployment readiness: fully validated deployment requirements / in-scope applicable target-environment deployment requirements. 11. Rollback readiness: fully validated rollback requirements / in-scope applicable rollback requirements. For coverage items report Fully validated, Implemented but unvalidated, Partially validated, Not tested, Blocked and Failed; list Not applicable separately with reasons. For a single status per item use Failed if a check failed; otherwise Blocked if a prerequisite prevents a required check; otherwise Fully validated if all required evidence passes; otherwise Partially validated if some evidence exists; otherwise Implemented but unvalidated if implemented; otherwise Not tested. Retain all evidence and blockers, so counts reconcile to the denominator. Count implemented features for migration coverage independently of validation status: an implemented feature can also be Blocked or Failed. Task completion is not validation coverage. Percentages are indicators, not success criteria: one missing critical workflow, security defect, data-loss risk or unverified mandatory integration prevents PASS or PASS WITH ISSUES. ### Retirement safeguard Report whether separate user authorization and all retirement prerequisites exist: target outcome for every original feature; parity status for every UI page/control/master/layout; CSS/HTML/JS/assets compared; database/data and authentication continuity verified or explicitly accepted; integrations tested or manually validated; manual checks completed or explicitly accepted as blocked; no unresolved Critical or High findings; and rollback artifacts. Accepted limitations remain unverified and do not become PASS. Never delete or retire a legacy project during validation. --- # 2. Core Validation Principles Follow these principles throughout validation. ## 2.1 Independence Do not blindly trust: - Executor completion reports. - Execution log statuses. - Claims that tests passed. - Claims that all projects were migrated. - Claims that dependencies were replaced. - Claims that business functionality was preserved. - Claims that deployment is successful. Verify important claims against actual source code, project files, test results, and runtime behavior. The execution log is a reference, not proof. ## 2.2 Original functionality is the baseline Use `UPGRADE_READINESS.md` as the original application knowledge baseline. Use the original feature inventory to verify that functionality has not been lost. The upgraded application must preserve the existing business functionality unless a change was explicitly approved in the migration plan. ## 2.3 The approved migration plan is the target Use `UPGRADE_PLAN.md` to establish: - Approved target framework. - Approved project scope. - Expected architecture changes. - Required migration tasks. - Dependencies. - Acceptance criteria. - Excluded scope. - Expected validation requirements. Do not treat optional improvements as mandatory requirements. ## 2.4 Evidence-based conclusions Every significant finding must contain evidence. Use: - Project paths. - Source file paths. - Classes and methods. - Line references where possible. - Build logs. - Test results. - Runtime results. - Configuration references. - API response comparisons. - Database comparison evidence. - Document output comparisons. Do not invent test results or claim something works without verification. ## 2.5 Distinguish verified and unverified functionality A feature that cannot be executed because infrastructure, data, credentials, or an external service is unavailable must not be classified as passed. Clearly distinguish: - Passed. - Failed. - Partially Validated. - Not Tested. - Blocked. - Not Applicable. ## 2.6 No automatic remediation This skill is for independent validation and reporting. Do not modify application source code to fix discovered issues. Do not upgrade packages, refactor code, or change configuration. Report the problems and recommend corrective actions. A separate executor run should implement approved corrections. --- # 3. Mandatory Input Documents Before beginning validation, account for the complete contents of the following documents in bounded sections and recorded handoffs when necessary; also inspect UPGRADE_COVERAGE.md and its original baseline when available. ## 3.1 UPGRADE_READINESS.md Use this document to understand the original application. Pay particular attention to: - Project inventory. - Application architecture. - Business feature inventory. - Project dependency matrix. - Design patterns. - Hidden execution paths. - Startup and shutdown behavior. - Legacy web technologies. - Windows-specific dependencies. - XML and Excel processing. - Database architecture. - WCF and legacy communication. - External integrations. - Security. - Testing coverage. - Original framework dependencies. - Known migration risks. This document establishes what existed before migration. ## 3.2 UPGRADE_PLAN.md Use this document to understand what was approved for migration. Identify: - Approved target framework. - Approved migration strategy. - Projects included in scope. - Mandatory migration tasks. - Optional modernization tasks. - Deferred tasks. - User-approved architectural decisions. - Acceptance criteria. - Required tests. - Excluded scope. - Rollback expectations. Do not penalize the migration for intentionally deferred work that is outside the approved scope. ## 3.3 UPGRADE_APPROVAL.md Verify that the executed plan was authorized. Inspect: - Approval status. - Approved plan version. - Approved plan fingerprint. - Approved target framework. - Approved project scope. - Approved migration tasks. - Explicit user approval statement. Compare the recorded fingerprint against the relevant approved plan version and execution records. If the plan changed after approval, investigate whether renewed approval was obtained. Report unauthorized scope expansion or missing approval evidence. ## 3.4 UPGRADE_EXECUTION_LOG.md Use this document to identify what the executor claims to have changed. Review: - Completed tasks. - Blocked tasks. - Deferred tasks. - Modified files. - Package changes. - Build results. - Test results. - Known issues. - Migration deviations. - Remaining work. Independently verify important execution claims. ## 3.5 Actual upgraded repository The actual source code and project configuration are the final evidence of implementation. Inspect the repository even when the execution log claims a task is completed. Do not rely exclusively on generated reports. --- # 4. Validation Status and Overall Result Use the following overall validation statuses. ## PASS The migration meets the approved acceptance criteria. All mandatory projects build successfully, critical functionality has been validated, and no unresolved Critical or High migration defects remain. Mandatory integration and environment-dependent scenarios must have sufficient evidence. ## PASS WITH ISSUES The major migration objectives have been achieved, but non-blocking issues remain. Examples: - Medium or Low severity findings. - Non-critical warnings. - Deferred testing only for non-mandatory, non-critical scenarios. - Minor performance differences. - Optional improvements not completed. All outstanding issues must be documented. No unresolved Critical or High finding, unverified mandatory integration, critical workflow, security defect or data-loss risk is compatible with PASS WITH ISSUES. ## FAIL The migration has significant unresolved defects. Examples: - Critical functionality no longer works. - Mandatory projects do not build. - Unsupported runtime dependencies remain. - Major API contracts are broken. - Core business features are missing. - Security behavior is broken. - Required application components cannot run. ## INCONCLUSIVE There is insufficient evidence to establish migration success or failure. Examples: - External systems are unavailable. - Required test environments are missing. - The original application baseline is incomplete. - Critical business workflows cannot be executed. - Deployment configuration cannot be verified. Never classify an inconclusive result as a pass. --- # 5. Phase 1: Establish the Validation Baseline Before validating the upgraded application, establish what is being tested. Inspect: - Git working tree. - Current branch. - Original baseline information. - Current solution structure. - Current project files. - Target frameworks. - NuGet dependencies. - Build environment. - Installed SDKs. - Installed runtimes. - Existing deployment configuration. - Generated migration artifacts. Determine whether the repository corresponds to the version described in the execution log. ## 5.1 Verify the migration scope Compare: 1. Approved migration scope. 2. Actual modified files. 3. Completed migration task IDs. 4. Actual project framework changes. 5. Package changes. 6. Architectural changes. Identify: - Missing migration tasks. - Unapproved changes. - Changes outside scope. - Projects not migrated. - Unexpectedly deleted files. - Missing project references. - Removed dependencies. - Deferred work incorrectly reported as completed. Do not automatically reject an approved optional change, but verify that it was authorized. ## 5.2 Environment verification Identify: - Installed .NET SDKs. - Installed runtimes. - MSBuild version. - Visual Studio Build Tools. - Required workloads. - Native compilation dependencies. - Operating system. - Architecture. - Environment configuration. Verify that the validation environment matches the intended deployment environment as closely as possible. Document differences between validation and production environments. ## 5.3 Original versus upgraded baseline Where baseline information exists, compare: - Original build results. - Original test results. - Original warnings. - Original application behavior. - Existing known issues. Distinguish pre-existing defects from migration regressions. Do not report an existing issue as newly introduced by the migration without evidence. --- # 6. Phase 2: Project and Framework Validation Inspect every project independently. Verify: - Target framework. - SDK requirement. - Project type. - Output type. - Project references. - Package references. - Build configurations. - Conditional compilation. - Runtime configuration. - Native dependencies. - Platform requirements. Compare actual project configuration against the approved migration plan. Create a project validation matrix. | Project | Original Framework | Expected Framework | Actual Framework | Build Status | Validation | |---|---|---|---|---|---| Identify: - Projects still targeting the old framework. - Projects excluded accidentally. - Projects targeting an incorrect version. - Shared libraries with incompatible targets. - Incorrect project references. - Projects that cannot load under the expected SDK. - Invalid conditional build configurations. - Broken test projects. - Incorrect runtime identifiers. Do not assume that a solution builds successfully simply because its main executable project builds. All mandatory projects must be considered. --- # 7. Phase 3: NuGet and Dependency Validation Independently inspect package references. Verify: - All required packages are restored. - Packages support the target framework. - Required package versions are correct. - No incompatible transitive dependencies remain. - No unsupported packages are overlooked. - Native dependencies are available. - Package assets are correctly resolved. - Version conflicts are understood. - Required runtime-specific assets are present. Review: - Microsoft.Extensions packages. - ASP.NET packages. - Entity Framework and EF Core. - SQL client libraries. - Newtonsoft.Json. - System.Text.Json. - XML libraries. - Excel libraries. - Logging providers. - Authentication packages. - Azure SDKs. - Third-party UI controls. - Native libraries. - COM dependencies. Identify obsolete packages, deprecated APIs, and packages with unsupported target frameworks. Do not classify a package as compatible merely because NuGet restore succeeds. Compilation and runtime compatibility must also be considered. Create a package validation matrix. | Package | Expected Version | Actual Version | Compatibility | Finding | |---|---|---|---|---| --- # 8. Phase 4: Build Validation Build every mandatory project and the complete solution where possible. Use the approved SDK and target framework. Validate: - Restore. - Build. - Release configuration. - Debug configuration where relevant. - Required platform configurations. - Test project builds. - Dependent project builds. - Published application build where applicable. Record: - Build command. - Environment. - Project or solution. - Target framework. - Build result. - Error count. - Warning count. - Relevant error messages. Investigate: - Missing references. - Incompatible APIs. - Ambiguous types. - Package conflicts. - Build target failures. - Incorrect resource inclusion. - Missing generated files. - Native DLL loading problems. - Platform-specific compilation issues. Do not hide failures by disabling projects or tests. Do not suppress warnings without understanding why they exist. Classify warnings as: - Migration-related. - Pre-existing. - New but non-blocking. - Requires investigation. A successful build is necessary but not sufficient for migration success. --- # 9. Phase 5: Application Startup and Shutdown Validation Validate the application's complete lifecycle. Investigate: - Main methods. - Startup classes. - Generic Host. - Web Host. - Dependency injection. - Service initialization. - Static initialization. - Application startup events. - Shutdown events. - Hosted services. - Background workers. - Resource cleanup. - Cancellation. - Graceful shutdown. Test, where possible: 1. Application starts successfully. 2. Dependencies initialize correctly. 3. Configuration is loaded. 4. Services are registered correctly. 5. Database connections initialize. 6. Background processes start. 7. The application serves requests. 8. Shutdown occurs gracefully. 9. Resources are disposed. 10. No unexpected exceptions occur. Pay particular attention to: - Initialization ordering. - Singleton and scoped dependency behavior. - Dependency injection disposal. - Background service startup. - Service startup failures. - Shutdown timeout behavior. - Unobserved exceptions. - Resource leaks. Compare the original lifecycle behavior with the upgraded implementation. --- # 10. Phase 6: Legacy Web Application and UI Validation This phase is mandatory when the original application contains web technologies. Validate the migrated web applications independently. ## 10.1 ASP.NET MVC and Razor Verify: - Controllers. - Actions. - Models. - View models. - Razor views. - `.cshtml`. - `.vbhtml`. - Layouts. - Partial views. - HTML helpers. - Custom tag helpers. - View components. - Routing. - Model binding. - Validation. - Filters. - Authentication. - Authorization. - Anti-forgery tokens. - Session handling. Identify: - Missing views. - Invalid model bindings. - Broken view discovery. - Incorrect layout rendering. - Missing partial views. - Broken HTML helpers. - Incorrect route generation. - Missing validation. - Incorrect form behavior. - Authentication regressions. - Session behavior differences. ## 10.2 Razor output validation Where feasible, compare the original and upgraded application behavior. Validate: - Page rendering. - Important HTML elements. - Navigation. - Forms. - Input names. - Hidden fields. - Validation messages. - JavaScript references. - Static assets. - URL generation. - Error pages. Do not require byte-for-byte identical HTML when legitimate framework-generated markup changes exist. Independently verify that any differences preserve visual presentation, semantics and selectors used by CSS, JavaScript, accessibility, automation and integrations, as well as behavior and user workflows. ## 10.3 ASP.NET Web Forms migration validation If the original application contained Web Forms: - Verify that every in-scope ASPX page has a migration outcome. - Verify that important code-behind business logic has been preserved. - Verify that master page functionality has been migrated. - Verify that user controls have replacements. - Verify that PostBack workflows are preserved. - Verify that ViewState-dependent operations are redesigned correctly. - Verify that server control validation is preserved. - Verify that UpdatePanel functionality is replaced where required. - Verify authentication and session behavior. - Verify third-party control functionality. Identify Web Forms components that still exist. Determine whether they are: - Intentionally retained as a separately hosted legacy application. - Fully migrated. - Partially migrated. - Accidentally left behind. - No longer needed with documented approval. Remember that ASP.NET Web Forms cannot run directly on ASP.NET Core. Do not consider a project migrated merely because its business logic compiles in a modern class library. The original user-facing workflows must also be accounted for. ## 10.4 Routing and request pipeline Validate: - Conventional routes. - Attribute routes. - Custom route constraints. - Authentication middleware. - Authorization middleware. - Exception middleware. - Session middleware. - Static file handling. - URL rewriting. - Custom endpoint routing. Identify differences in request execution order. ## 10.5 IIS and hosting validation Verify: - IIS configuration. - Application pools. - Handler configuration. - Authentication settings. - URL rewriting. - Request limits. - Static content delivery. - Environment variables. - Hosting bundle requirements. - HTTPS configuration. Do not assume a locally running Kestrel application proves IIS deployment compatibility. --- # 11. Phase 7: Windows and Platform Compatibility Validation Verify the treatment of: - Windows Services. - ServiceBase. - Windows Registry. - WMI. - Windows Event Log. - COM Interop. - P/Invoke. - Native DLLs. - Windows Authentication. - Impersonation. - NTFS permissions. - Named pipes. - PowerShell. - System.Drawing. - Windows Forms. - Printing. - GDI. For each component, verify: - Original functionality. - Migration strategy. - Target framework compatibility. - Target operating system compatibility. - Runtime dependency. - Successful execution. - Error handling. If cross-platform deployment was approved, conduct additional validation on the intended non-Windows environment. Check: - File path handling. - File permissions. - Case sensitivity. - Native library loading. - Process execution. - Environment variables. - Authentication. - Encoding. - Printing assumptions. - Platform-specific APIs. A successful Windows build does not establish Linux compatibility. --- # 12. Phase 8: Background Services and Scheduled Process Validation Validate: - Windows Services. - Worker Services. - IHostedService. - BackgroundService. - Timers. - BackgroundWorker. - Scheduled jobs. - Custom threads. - Message consumers. - Polling processes. - Batch operations. For each background process, verify: - It starts. - It executes the expected operation. - It uses the correct dependencies. - It processes data correctly. - It handles exceptions. - It logs failures. - It supports cancellation. - It stops correctly. - It releases resources. Investigate: - Duplicate job execution. - Concurrency problems. - Missing timer registrations. - Incorrect scheduling. - Unhandled exceptions. - Task abandonment. - Resource leaks. - Shutdown race conditions. - Missing cancellation token propagation. Preserve the original execution frequency and scheduling behavior unless a change was explicitly approved. Where possible, compare representative processing results between the original and upgraded applications. --- # 13. Phase 9: XML, Excel and Document Processing Validation Perform a dedicated document-processing regression assessment. Validate: - XML parsing. - XML serialization. - XPath. - XSLT. - Schema validation. - Excel reading. - Excel generation. - CSV processing. - PDF generation. - Word document generation. - Document templates. Pay special attention to changes involving: - Office Interop. - COM automation. - OpenXML SDK. - EPPlus. - ClosedXML. - NPOI. - Other spreadsheet libraries. ## 13.1 Excel validation Compare representative original and migrated outputs. Verify: - Cell values. - Formulas. - Formatting. - Fonts. - Number formats. - Date formats. - Worksheets. - Named ranges. - Merged cells. - Images. - Hidden rows and columns. - Print settings. - Workbook metadata. - File compatibility. Test: - Empty workbooks. - Large files. - Missing worksheets. - Invalid input. - Special characters. - Culture-dependent values. - Dates. - Decimals. - Concurrent file processing. ## 13.2 XML validation Verify: - Namespaces. - Elements. - Attributes. - Encoding. - Schema compatibility. - Element ordering where significant. - Optional elements. - Null values. - Serialization compatibility. Compare original and upgraded XML semantically where formatting or whitespace differences are harmless. ## 13.3 File processing validation Verify: - File import. - File export. - Stream disposal. - File locking. - Temporary file cleanup. - Memory usage. - File permissions. - Error handling. Do not claim document compatibility solely because the relevant libraries compile. --- # 14. Phase 10: Database and Persistence Validation Validate all persistence mechanisms. Inspect: - Entity Framework. - EF Core. - ADO.NET. - SQL clients. - Database providers. - Raw SQL. - Stored procedures. - Transactions. - Connection pooling. - Lazy loading. - Change tracking. - Database migrations. - Bulk operations. Verify: - Database connection initialization. - Query execution. - Data retrieval. - Inserts. - Updates. - Deletes. - Transactions. - Rollbacks. - Concurrency behavior. - Null handling. - Date and time values. - Decimal precision. - Data type mappings. - Stored procedure contracts. ## 14.1 Query behavior validation For important queries: - Compare original behavior. - Inspect generated SQL where relevant. - Validate filtering. - Validate sorting. - Validate joins. - Validate pagination. - Validate projections. - Check null handling. Identify differences caused by ORM migration or provider changes. ## 14.2 Database safety Use non-production validation databases wherever possible. Never run destructive tests against production. Do not execute database migrations that alter production schema without explicit authorization. Distinguish application compatibility from database schema migration success. --- # 15. Phase 11: Serialization and Data Compatibility Validate all serialization mechanisms. Investigate: - Newtonsoft.Json. - System.Text.Json. - XmlSerializer. - DataContractSerializer. - BinaryFormatter. - Custom serializers. - Custom converters. - Polymorphic serialization. For representative data, compare: - Property names. - Null handling. - Enum representations. - Date and time formats. - Numeric precision. - XML namespaces. - Type information. - Custom converter behavior. - Deserialization compatibility. Test compatibility with: - Existing persisted data. - Previously generated documents. - External API consumers. - Message queues. - Cached objects. - Existing integration payloads. Pay particular attention to stored serialized objects and data that outlives an application deployment. A successful round trip using only newly generated data does not prove compatibility with historical data. --- # 16. Phase 12: WCF, Messaging and Legacy Communication Validation If present in the original application, validate: - WCF services. - WCF clients. - SOAP. - ASMX. - Service contracts. - Data contracts. - Client proxies. - BasicHttpBinding. - WSHttpBinding. - NetTcpBinding. - Custom bindings. - Duplex communication. - Message security. - WSDL. - .NET Remoting. - AppDomain communication. - MSMQ. - Named pipes. - Custom TCP protocols. - Message brokers. Verify: - Service availability. - Endpoint configuration. - Request and response contracts. - Authentication. - Authorization. - Serialization. - Fault handling. - Timeouts. - Retry policies. - Message ordering. - Idempotency. Where services were replaced by APIs or other protocols, validate communication with actual consumers. Do not assume a newly implemented endpoint is compatible merely because it serves a similar business purpose. --- # 17. Phase 13: External Integration Validation Verify all external integrations identified in the readiness document. Examples: - REST APIs. - SOAP. - Azure services. - AWS services. - Redis. - SMTP. - SFTP. - Third-party SDKs. - Authentication providers. - Message queues. - Monitoring systems. Validate: - Initialization. - Authentication. - Request and response formats. - Timeouts. - Retry handling. - Error handling. - Connection management. - TLS. - Serialization. - External contract compatibility. Where external environments are unavailable: - Mark the integration as Not Tested or Blocked. - Identify the missing prerequisite. - Explain the operational impact. - Do not claim the integration has passed. Never send unintended production traffic or perform external state-changing operations without authorization. --- # 18. Phase 14: Security Validation Independently review security-related migration changes. Inspect: - Authentication. - Authorization. - Windows Authentication. - Forms Authentication. - OAuth. - OpenID Connect. - JWT. - Cookie authentication. - Session management. - CSRF protection. - XSS protection. - Input validation. - Cryptography. - Certificates. - TLS. - Secret management. - Connection strings. Identify: - Weakened security policies. - Removed authorization checks. - Missing authentication middleware. - Incorrect middleware ordering. - Cookie behavior changes. - Missing anti-forgery protections. - Certificate loading problems. - Insecure TLS configurations. - Hardcoded secrets. - Weakened cryptographic settings. - Sensitive information exposed in logs. Do not attempt penetration testing or destructive security testing outside the approved validation scope. Document security findings separately and assign appropriate severity. --- # 19. Phase 15: Architecture and Code Quality Validation Compare the actual upgraded architecture against the approved plan. Check: - Project boundaries. - Dependency direction. - Dependency injection. - Service lifetimes. - Repository implementations. - Middleware. - Handler registration. - Reflection. - Static service references. - Direct dependencies. - Circular dependencies. - Assembly loading. - Custom abstractions. Identify: - Unapproved architecture changes. - Missing abstractions. - Incorrect service registrations. - Duplicate implementations. - Dead code introduced during migration. - Unnecessary project dependencies. - Hidden legacy dependencies that remain. - Changes in execution flow. - Business logic unintentionally moved or duplicated. Do not enforce arbitrary code style preferences. A legacy application does not need to be fully redesigned to pass a framework upgrade validation. Focus on correctness, compatibility, maintainability, and adherence to the approved migration plan. --- # 20. Phase 16: Performance and Resource Validation Where performance baselines are available, compare the original and upgraded applications. Evaluate: - Startup time. - Memory consumption. - CPU utilization. - HTTP response times. - Database query performance. - Background processing time. - File processing time. - Thread usage. - Connection pooling. - Resource disposal. - Application shutdown time. Investigate: - Memory leaks. - Excessive allocations. - Thread pool starvation. - Database connection exhaustion. - Blocking asynchronous operations. - Resource disposal failures. - Unexpectedly slow queries. - Increased file-processing memory. Use equivalent test environments and workloads when making performance comparisons. Do not claim a performance improvement without measurements. If no baseline exists, document the limitation. --- # 21. Phase 17: Regression Testing and Feature Preservation This phase determines whether existing application functionality has survived migration. Use the original feature inventory from `UPGRADE_READINESS.md`. Map each original feature to: - Its original project. - Its original execution path. - Its migrated implementation. - Its related migration tasks. - Its test evidence. - Its current validation status. Create a feature validation matrix. | Feature ID | Feature | Original Implementation | Migrated Implementation | Test Evidence | Result | |---|---|---|---|---|---| Validate: 1. Core business workflows. 2. API endpoints. 3. Authentication. 4. Authorization. 5. Database operations. 6. Scheduled jobs. 7. Background services. 8. File processing. 9. XML workflows. 10. Excel workflows. 11. Web UI functionality. 12. External integrations. 13. Error handling. 14. Logging and monitoring. ## 21.1 Feature-level pass criteria A feature passes when: - The feature still exists or has an explicitly approved replacement. - Its intended business behavior is preserved. - Its dependencies work. - Its entry points are functional. - Its outputs are correct. - Relevant tests pass. If only part of a feature is validated, mark it Partially Validated. If a feature cannot be tested, mark it Not Tested or Blocked. Do not automatically classify missing test coverage as a functional regression. However, identify the lack of verification as a validation gap. ## 21.2 Missing functionality Identify: - Original features with no migrated implementation. - Controllers or endpoints that disappeared. - Missing background jobs. - Missing scheduled processes. - Missing UI pages. - Removed integrations. - Missing reports. - Removed import/export functionality. - Missing handlers. - Missing event subscriptions. - Functionality silently bypassed. Every missing feature must be explicitly reported. --- # 22. Phase 18: Deployment and Infrastructure Validation Validate the actual deployment model. Inspect: - IIS hosting. - Kestrel. - Windows Service hosting. - Worker Service hosting. - Docker. - Container images. - Linux deployment. - Windows deployment. - CI/CD pipelines. - Runtime installation. - Environment variables. - Certificates. - Static file configuration. - Health checks. - Monitoring. - Logging. - Process management. Verify: - Application publish succeeds. - Required files are included. - Runtime dependencies are available. - Configuration loads correctly. - Environment-specific behavior works. - Application starts under the intended host. - Health checks work. - Application shuts down gracefully. Where a deployment environment is unavailable, clearly identify what has and has not been verified. Do not deploy to production as part of this skill. Production deployment requires separate authorization. --- # 23. Phase 19: Migration Plan and Execution Compliance Compare the approved migration plan against the actual implementation. For every migration task, verify: - Task ID. - Project. - Expected change. - Actual change. - Acceptance criteria. - Build evidence. - Test evidence. - Status. Create a migration task compliance matrix. | Task ID | Planned Change | Actual Change | Evidence | Status | |---|---|---|---|---| Identify: - Tasks not implemented. - Tasks partially implemented. - Tasks incorrectly marked complete. - Tasks implemented without sufficient tests. - Tasks implemented differently from the approved approach. - Changes outside the approved scope. - Deferred tasks accidentally included. - Missing rollback documentation. Do not accept an execution log status as proof of completion. --- # 24. Phase 20: Finding Classification and Problem Reporting Every identified problem must receive a unique finding ID. Use the following severity classification. ## Critical A serious issue that prevents successful migration or causes major application failure. Examples: - Mandatory application project cannot build. - Core business functionality no longer works. - Critical data corruption. - Security bypass. - Essential service cannot start. - Unsupported mandatory runtime component remains. - Critical API contract is broken. ## High A major issue affecting an important subsystem or required workflow. Examples: - Important feature missing. - Major UI workflow broken. - Background processing no longer works. - Database behavior changed. - Required external integration broken. - Migration fails on the intended deployment platform. ## Medium A non-critical issue that requires correction or further investigation. Examples: - Non-critical feature regression. - Incorrect formatting in exported documents. - Performance degradation. - Incomplete validation. - Deprecated dependencies remaining. - Logging behavior differences. ## Low A minor issue or improvement opportunity. Examples: - Non-critical warnings. - Minor inconsistencies. - Non-blocking cleanup. - Optional modernization. ## 24.1 Confidence levels Also record confidence: - Confirmed: Directly verified. - Likely: Strong evidence, but incomplete verification. - Requires Validation: Cannot establish without a specific test or environment. - Informational: Technical observation without an established defect. ## 24.2 Mandatory finding structure Every important finding must include: | Field | Description | |---|---| | Finding ID | e.g. VAL-001 | | Severity | Critical, High, Medium, Low | | Confidence | Confirmed, Likely, Requires Validation | | Category | Build, Runtime, UI, Database, Security, etc. | | Related Task | Migration task ID | | Original Feature | Feature ID where applicable | | Project | Affected project | | File | Repository-relative path | | Class/Method | Relevant implementation | | Expected Behavior | Original or approved behavior | | Actual Behavior | Observed behavior | | Evidence | Build, test, source or runtime evidence | | Impact | Business or technical consequence | | Root Cause | Established cause or unknown | | Recommendation | Proposed corrective action | | Validation Required | How to verify remediation | Do not invent root causes when evidence is insufficient. --- # 25. Phase 21: Validation Summary and Quality Gates Determine the overall migration status using evidence. ## PASS Use only when: - All mandatory projects build. - Approved target framework is implemented. - Mandatory migration tasks are complete. - Critical features are validated. - Core regression tests pass. - No unresolved Critical or High findings remain. - Mandatory integrations and deployment requirements have sufficient evidence. ## PASS WITH ISSUES Use when: - Core migration requirements are satisfied. - No unresolved Critical or High findings exist. - Remaining issues are non-blocking. - Outstanding risks are explicitly documented. - Mandatory integrations and critical workflows have sufficient evidence. ## FAIL Use when: - Critical compatibility issues remain. - Mandatory projects do not build. - Core business features are broken. - Major functionality is missing. - Security is compromised. - Essential services cannot run. ## INCONCLUSIVE Use when: - Insufficient test evidence exists. - Required environments are unavailable. - Important external integrations cannot be tested. - Critical application behavior cannot be established. - The original baseline is insufficient. A report must never claim PASS when required validation is missing. --- # 26. Phase 22: Required Output — UPGRADE_VALIDATION.md Create: `UPGRADE_VALIDATION.md` at the repository root. Use the following structure. ## 1. Executive Summary Include: - Original framework. - Target framework. - Overall validation result. - Projects evaluated. - Projects successfully building. - Mandatory tasks completed. - Critical findings. - High findings. - Outstanding validation gaps. ## 2. Validation Scope Document: - Projects evaluated. - Features evaluated. - Platforms evaluated. - Integrations evaluated. - Excluded scope. ## 3. Validation Methodology Explain: - Source code inspection. - Build validation. - Automated testing. - Runtime verification. - Regression comparison. - Environment limitations. ## 4. Source Document Verification Document the readiness, migration plan, approval, and execution log versions reviewed. ## 5. Approval and Scope Verification Document plan version, approval evidence, fingerprint verification, and scope compliance. ## 6. Environment and SDK Validation Document SDK, runtime, build tools, operating system and environment compatibility. ## 7. Project Framework Validation Include the project validation matrix. ## 8. NuGet and Dependency Validation Include dependency compatibility findings. ## 9. Build Results Document solution and project build results. ## 10. Startup and Lifecycle Validation Document application startup, shutdown and service behavior. ## 11. Web Application and UI Validation Cover MVC, Razor, Web Forms, routing, IIS and frontend functionality. ## 12. Windows and Platform Compatibility Document platform-specific verification. ## 13. Background Service Validation Document worker and scheduled process results. ## 14. XML, Excel and Document Validation Document file processing, output compatibility and regression results. ## 15. Database Validation Document persistence, ORM and query validation. ## 16. Serialization and Data Compatibility Document data format verification. ## 17. WCF and Communication Validation Document legacy services and messaging. ## 18. External Integration Validation Document integration test results. ## 19. Security Validation Document authentication, authorization, certificates and security findings. ## 20. Architecture and Code Quality Review Document structural compliance and unexpected architecture changes. ## 21. Performance Validation Document measurements and limitations. ## 22. Feature Preservation Matrix Map original features to upgraded implementations. ## 23. Migration Task Compliance Compare approved plan tasks against actual execution. ## 24. Findings and Defects List all identified findings with severity, evidence and recommendations. ## 25. Outstanding Validation Gaps List untested features and missing prerequisites. ## 26. Overall Validation Decision PASS / PASS WITH ISSUES / FAIL / INCONCLUSIVE. Explain the decision. ## 27. Recommendations and Next Actions Prioritize corrective work. --- # 27. Phase 23: Required Output — REGRESSION_REPORT.md Create: `REGRESSION_REPORT.md` at the repository root. This document should focus specifically on whether the original application's functionality has been preserved. Use the following structure. ## 1. Regression Summary - Total original features identified. - Features fully validated. - Features passed. - Features failed. - Features partially validated. - Features not tested. - Features blocked. - Confirmed regressions. ## 2. Feature-by-Feature Results | Feature ID | Feature | Original Behavior | New Implementation | Test Result | Finding ID | |---|---|---|---|---|---| ## 3. API Regression Results Document: - Missing endpoints. - Changed routes. - Request contract differences. - Response differences. - Authentication differences. - Status code differences. - Serialization differences. ## 4. UI Regression Results Document: - Missing pages. - Rendering differences. - Broken forms. - Navigation problems. - Validation differences. - Session problems. - JavaScript issues. - Authentication problems. ## 5. Database Regression Results Document: - Query differences. - Incorrect data mappings. - Transaction behavior changes. - Missing records. - Incorrect null handling. - Date or precision differences. ## 6. Background Processing Regression Results Document: - Missing jobs. - Incorrect execution schedules. - Duplicate processing. - Failed event handlers. - Incorrect shutdown behavior. ## 7. XML, Excel and Document Regression Results Document: - Output changes. - Formatting differences. - Formula issues. - Missing worksheets. - XML schema differences. - Encoding issues. - File generation failures. ## 8. External Integration Regression Results Document integration compatibility and contract differences. ## 9. Security Regression Results Document changes affecting access control, authentication and security behavior. ## 10. Missing Functionality List original features that are missing, incomplete, or not migrated. ## 11. Regression Recommendations Provide prioritized actions to restore compatibility. ## 12. Final Regression Assessment State whether existing application functionality has been sufficiently preserved. --- # 28. Phase 24: Independent Validation Rules These rules are mandatory. 1. Do not trust executor reports without verification. 2. Inspect the actual upgraded source code. 3. Independently run builds where possible. 4. Independently run tests where possible. 5. Compare original and upgraded feature inventories. 6. Verify migration task acceptance criteria. 7. Investigate unexpected project and package changes. 8. Identify all missing features. 9. Report unverified functionality honestly. 10. Do not modify application code. 11. Do not automatically fix findings. 12. Do not deploy to production. 13. Do not perform destructive database operations. 14. Do not send unintended production requests. 15. Do not weaken security to make tests pass. 16. Do not claim PASS without sufficient evidence. The validator must behave as an independent reviewer, not as an extension of the executor. --- # 29. Phase 25: Recommendations for Corrective Work For each finding, recommend a corrective action. Group recommendations into: ### P0 — Immediate blockers Must be addressed before considering the migration successful. ### P1 — High priority Important functionality or compatibility issues requiring correction. ### P2 — Medium priority Issues that should be addressed before production release where relevant. ### P3 — Low priority Non-blocking improvements. For each recommendation, document: - Finding ID. - Suggested correction. - Affected project. - Relevant files. - Dependencies. - Expected outcome. - Suggested tests. - Whether plan revision is required. - Whether additional approval is required. Do not implement corrections during validation. If corrective changes are required, return the relevant findings to the planning and execution workflow. --- # 30. Phase 26: Scope Restrictions This skill is read-only with respect to application implementation. ## Allowed - Read UPGRADE_READINESS.md. - Read UPGRADE_PLAN.md. - Read UPGRADE_APPROVAL.md. - Read UPGRADE_EXECUTION_LOG.md. - Read UPGRADE_COVERAGE.md when available. - Inspect actual application source code. - Inspect project configurations. - Inspect package references. - Run safe builds. - Run approved automated tests. - Run non-destructive validation commands. - Execute tests against dedicated non-production environments. - Compare outputs. - Review code and configurations. - Create or update UPGRADE_VALIDATION.md. - Create or update REGRESSION_REPORT.md. ## Not Allowed - Change target frameworks. - Upgrade packages. - Modify application source code. - Refactor application code. - Change project files. - Change runtime configuration. - Modify database schemas. - Modify production data. - Modify CI/CD pipelines. - Deploy the application. - Automatically resolve discovered defects. - Delete files. - Change business behavior. Only create or update: - UPGRADE_VALIDATION.md - REGRESSION_REPORT.md If the validator identifies a problem, report it rather than silently fixing it. Testing may create temporary test outputs and logs, but must not modify production data or overwrite existing user files. Use dedicated test infrastructure and test data. If a test could cause destructive or externally visible changes, obtain explicit authorization before executing it. --- # 31. Phase 27: Final Verification Checklist Before completing validation, verify the following. ### Framework and project compatibility - All mandatory projects target the approved framework. - Project references are valid. - Required packages are compatible. - No unsupported dependencies remain without an approved strategy. - SDK and runtime requirements are documented. ### Build and runtime - Mandatory projects build. - Complete solution build is attempted. - Startup is validated. - Shutdown is validated. - Background processes are validated. - Deployment configuration is assessed. ### Web applications - MVC controllers are validated. - Razor views are validated. - Web Forms migration outcomes are verified. - Routes and middleware are validated. - IIS hosting is assessed. - Authentication and session behavior are checked. ### Legacy and platform-specific components - Windows dependencies are assessed. - COM dependencies are checked. - Native libraries are assessed. - WCF and messaging compatibility is checked. - XML and Excel functionality is validated. - File-processing behavior is reviewed. ### Data and business functionality - Database behavior is checked. - Serialization compatibility is checked. - External integrations are assessed. - Original business features are mapped. - Missing functionality is reported. - Regression tests are evaluated. ### Quality and reporting - Findings include evidence. - Severity classifications are justified. - Unverified areas are clearly identified. - No application code has been modified. - Overall validation status is evidence-based. - Both validation reports are complete. --- # 32. Final Completion Report At completion, provide a summary containing: 1. Location of UPGRADE_VALIDATION.md. 2. Location of REGRESSION_REPORT.md. 3. Original framework. 4. Target framework. 5. Number of projects inspected. 6. Number of projects successfully building. 7. Number of projects failing to build. 8. Number of original features identified. 9. Number of features successfully validated. 10. Number of confirmed regressions. 11. Number of Critical findings. 12. Number of High findings. 13. Number of Medium findings. 14. Number of Low findings. 15. Number of features not tested. 16. Most important compatibility concerns. 17. Most important corrective actions. 18. Overall validation result. 19. Production readiness limitations. Clearly distinguish actual defects from missing test evidence. Do not claim the application is production-ready merely because migration validation passed. Production readiness requires its own release and operational approval. --- # SUCCESS CRITERIA The validation phase is successful when an independent reviewer can establish: 1. The application targets the approved framework. 2. All mandatory projects are compatible. 3. Package dependencies are supported. 4. The application builds. 5. Application startup and shutdown work. 6. Existing business functionality has been assessed. 7. Public API contracts remain compatible. 8. Database behavior is preserved. 9. Legacy web functionality is preserved or migrated. 10. Background services behave correctly. 11. XML and Excel functionality remains compatible. 12. External integrations are verified. 13. Security behavior is preserved. 14. Deployment compatibility is established to the required level. 15. All detected regressions are documented. 16. All important validation gaps are disclosed. 17. The final reports contain sufficient evidence for corrective action. **The ultimate objective is to independently establish whether the .NET migration was successful, identify anything that broke or was overlooked, and provide an actionable report that allows the team to correct problems before considering the upgrade complete.**