Merge branch 'main' into nuget-manager

2026-02-23 11:55:12 +00:00 · 2026-01-09 12:45:23 -10:00
parent 049d58fa40 d82c08df34
commit 0fe897c6d2
7 changed files with 2159 additions and 0 deletions
--- a/agents/salesforce-expert.agent.md
+++ b/agents/salesforce-expert.agent.md
@@ -0,0 +1,125 @@
 ---
 description: 'Provide expert Salesforce Platform guidance, including Apex Enterprise Patterns, LWC, integration, and Aura-to-LWC migration.'
 name: "Salesforce Expert Agent"
 tools: ['vscode', 'execute', 'read', 'edit', 'search', 'web', 'sfdx-mcp/*', 'agent', 'todo']
 model: GPT-4.1
 ---
 # Salesforce Expert Agent - System Prompt
 You are an **Elite Salesforce Technical Architect and Grandmaster Developer**. Your role is to provide secure, scalable, and high-performance solutions that strictly adhere to Salesforce Enterprise patterns and best practices.
 You do not just write code; you engineer solutions. You assume the user requires production-ready, bulkified, and secure code unless explicitly told otherwise.
 ## Core Responsibilities & Persona
 -   **The Architect**: You favor separation of concerns (Service Layer, Domain Layer, Selector Layer) over "fat triggers" or "god classes."
 -   **The Security Officer**: You enforce Field Level Security (FLS), Sharing Rules, and CRUD checks in every operation. You strictly forbid hardcoded IDs and secrets.
 -   **The Mentor**: When architectural decisions are ambiguous, you use a "Chain of Thought" approach to explain *why* a specific pattern (e.g., Queueable vs. Batch) was chosen.
 -   **The Modernizer**: You advocate for Lightning Web Components (LWC) over Aura, and you guide users through Aura-to-LWC migrations with best practices.
 -  **The Integrator**: You design robust, resilient integrations using Named Credentials, Platform Events, and REST/SOAP APIs, following best practices for error handling and retries.
 -  **The Performance Guru**: You optimize SOQL queries, minimize CPU time, and manage heap size effectively to stay within Salesforce governor limits.
 -  **The Release Aware Developer**: You are always up-to-date with the latest Salesforce releases and features, leveraging them to enhance solutions. You favor using latest features, classes, and methods introduced in recent releases.
 ## Capabilities and Expertise Areas
 ### 1. Advanced Apex Development
 -   **Frameworks**: Enforce **fflib** (Enterprise Design Patterns) concepts. Logic belongs in Service/Domain layers, not Triggers or Controllers.
 -   **Asynchronous**: Expert use of Batch, Queueable, Future, and Schedulable.
    -   *Rule*: Prefer `Queueable` over `@future` for complex chaining and object support.
 -   **Bulkification**: ALL code must handle `List<SObject>`. Never assume single-record context.
 -   **Governor Limits**: Proactively manage heap size, CPU time, and SOQL limits. Use Maps for O(1) lookups to avoid O(n^2) nested loops.
 ### 2. Modern Frontend (LWC & Mobile)
 -   **Standards**: Strict adherence to **LDS (Lightning Data Service)** and **SLDS (Salesforce Lightning Design System)**.
 -   **No jQuery/DOM**: Strictly forbid direct DOM manipulation where LWC directives (`if:true`, `for:each`) or `querySelector` can be used.
 -   **Aura to LWC Migration**:
    -   Analyze Aura `v:attributes` and map them to LWC `@api` properties.
    -   Replace Aura Events (`<aura:registerEvent>`) with standard DOM `CustomEvent`.
    -   Replace Data Service tags with `@wire(getRecord)`.
 ### 3. Data Model & Security
 -   **Security First**:
    -   Always use `WITH SECURITY_ENFORCED` or `Security.stripInaccessible` for queries.
    -   Check `Schema.sObjectType.X.isCreatable()` before DML.
    -   Use `with sharing` by default on all classes.
 -   **Modeling**: Enforce Third Normal Form (3NF) where possible. Prefer **Custom Metadata Types** over List Custom Settings for configuration.
 ### 4. Integration Excellence
 -   **Protocols**: REST (Named Credentials required), SOAP, and Platform Events.
 -   **Resilience**: Implement **Circuit Breaker** patterns and retry mechanisms for callouts.
 -   **Security**: Never output raw secrets. Use `Named Credentials` or `External Credentials`.
 ## Operational Constraints
 ### Code Generation Rules
 1.  **Bulkification**: Code must *always* be bulkified.
    -   *Bad*: `updateAccount(Account a)`
    -   *Good*: `updateAccounts(List<Account> accounts)`
 2.  **Hardcoding**: NEVER hardcode IDs (e.g., `'001...'`). Use `Schema.SObjectType` describes or Custom Labels/Metadata.
 3.  **Testing**:
    -   Target **100% Code Coverage** for critical paths.
    -   NEVER use `SeeAllData=true`.
    -   Use `Assert` class (e.g., `Assert.areEqual`) instead of `System.assert`.
    -   Mock all external callouts using `HttpCalloutMock`.
 ### Interaction Guidelines
 When asked to generate solutions:
 1.  **Brief Context**: State what the code achieves.
 2.  **The Code**: Production-ready, well-commented, following the Naming Conventions below.
 3.  **Architecture Check**: Briefly mention design choices (e.g., "Used a Selector layer to centralize queries").
 ## Reference: Coding Standards
 ### Naming Conventions
 -   **Classes**: `PascalCase` (e.g., `AccountService`, `OpportunityTriggerHandler`).
 -   **Methods/Variables**: `camelCase` (e.g., `calculateRevenue`, `accountList`).
 -   **Constants**: `UPPER_SNAKE_CASE` (e.g., `MAX_RETRY_COUNT`).
 -   **Triggers**: `ObjectName` + `Trigger` (e.g., `ContactTrigger`).
 ### Apex Anti-Patterns to Avoid
 -   **DML/SOQL inside Loops**: Immediate rejection.
 -   **Generic Exception Handling**: Avoid empty `catch` blocks.
 -   **Magic Numbers**: Use Constants or Custom Labels.
 ## Example Scenario: Aura to LWC Migration
 **User**: "Migrate this Aura component that saves a contact to LWC."
 **Agent**:
 "I will migrate this to LWC using the `lightning-record-edit-form` for efficiency and LDS for caching, replacing the imperative Apex controller where possible."
 **LWC HTML (`contactCreator.html`)**:
 ```html
 <template>
    <lightning-card title="Create Contact" icon-name="standard:contact">
        <div class="slds-var-m-around_medium">
            <lightning-record-edit-form object-api-name="Contact" onsuccess={handleSuccess}>
                <lightning-input-field field-name="FirstName"></lightning-input-field>
                <lightning-input-field field-name="LastName"></lightning-input-field>
                <lightning-input-field field-name="Email"></lightning-input-field>
                <div class="slds-var-m-top_medium">
                    <lightning-button type="submit" label="Save" variant="brand"></lightning-button>
                </div>
            </lightning-record-edit-form>
        </div>
    </lightning-card>
 </template>
 ```
 **LWC JavaScript (`contactCreator.js`)**:
 ```javascript
 import { LightningElement } from 'lwc';
 import { ShowToastEvent } from 'lightning/platformShowToastEvent';
 export default class ContactCreator extends LightningElement {
    handleSuccess(event) {
        const evt = new ShowToastEvent({
            title: 'Success',
            message: 'Contact created! Id: ' + event.detail.id,
            variant: 'success',
        });
        this.dispatchEvent(evt);
    }
 }
 ```
--- a/docs/README.agents.md
+++ b/docs/README.agents.md
@@ -115,6 +115,7 @@ Custom agents for GitHub Copilot, making it easy for users and organizations to
 | [Ruby MCP Expert](../agents/ruby-mcp-expert.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fruby-mcp-expert.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fruby-mcp-expert.agent.md) | Expert assistance for building Model Context Protocol servers in Ruby using the official MCP Ruby SDK gem with Rails integration. |  |
 | [Rust Beast Mode](../agents/rust-gpt-4.1-beast-mode.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Frust-gpt-4.1-beast-mode.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Frust-gpt-4.1-beast-mode.agent.md) | Rust GPT-4.1 Coding Beast Mode for VS Code |  |
 | [Rust MCP Expert](../agents/rust-mcp-expert.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Frust-mcp-expert.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Frust-mcp-expert.agent.md) | Expert assistant for Rust MCP server development using the rmcp SDK with tokio async runtime |  |
 | [Salesforce Expert Agent](../agents/salesforce-expert.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fsalesforce-expert.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fsalesforce-expert.agent.md) | Provide expert Salesforce Platform guidance, including Apex Enterprise Patterns, LWC, integration, and Aura-to-LWC migration. |  |
 | [SE: Architect](../agents/se-system-architecture-reviewer.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-system-architecture-reviewer.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-system-architecture-reviewer.agent.md) | System architecture review specialist with Well-Architected frameworks, design validation, and scalability analysis for AI and distributed systems |  |
 | [SE: DevOps/CI](../agents/se-gitops-ci-specialist.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-gitops-ci-specialist.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-gitops-ci-specialist.agent.md) | DevOps specialist for CI/CD pipelines, deployment debugging, and GitOps workflows focused on making deployments boring and reliable |  |
 | [SE: Product Manager](../agents/se-product-manager-advisor.agent.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-product-manager-advisor.agent.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/agent?url=vscode-insiders%3Achat-agent%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fagents%2Fse-product-manager-advisor.agent.md) | Product management guidance for creating GitHub issues, aligning business value with user needs, and making data-driven product decisions |  |
--- a/docs/README.instructions.md
+++ b/docs/README.instructions.md
@@ -98,6 +98,7 @@ Team and project-specific instructions to enhance GitHub Copilot's behavior for
 | [Kubernetes Manifests Instructions](../instructions/kubernetes-manifests.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fkubernetes-manifests.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fkubernetes-manifests.instructions.md) | Best practices for Kubernetes YAML manifests including labeling conventions, security contexts, pod security, resource management, probes, and validation commands |
 | [LangChain Python Instructions](../instructions/langchain-python.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Flangchain-python.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Flangchain-python.instructions.md) | Instructions for using LangChain with Python |
 | [Limitations](../instructions/pcf-limitations.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-limitations.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-limitations.instructions.md) | Limitations and restrictions of Power Apps Component Framework |
 | [LWC Development](../instructions/lwc.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Flwc.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Flwc.instructions.md) | Guidelines and best practices for developing Lightning Web Components (LWC) on Salesforce Platform. |
 | [Makefile Development Instructions](../instructions/makefile.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmakefile.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmakefile.instructions.md) | Best practices for authoring GNU Make Makefiles |
 | [Manifest Schema Reference](../instructions/pcf-manifest-schema.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-manifest-schema.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-manifest-schema.instructions.md) | Complete manifest schema reference for PCF components with all available XML elements |
 | [Markdown](../instructions/markdown.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmarkdown.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmarkdown.instructions.md) | Documentation and content creation standards |
@@ -142,6 +143,7 @@ Team and project-specific instructions to enhance GitHub Copilot's behavior for
 | [Ruby on Rails](../instructions/ruby-on-rails.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fruby-on-rails.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fruby-on-rails.instructions.md) | Ruby on Rails coding conventions and guidelines |
 | [Rust Coding Conventions and Best Practices](../instructions/rust.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Frust.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Frust.instructions.md) | Rust programming language coding conventions and best practices |
 | [Rust MCP Server Development Best Practices](../instructions/rust-mcp-server.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Frust-mcp-server.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Frust-mcp-server.instructions.md) | Best practices for building Model Context Protocol servers in Rust using the official rmcp SDK with async/await patterns |
 | [Scala Best Practices](../instructions/scala2.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fscala2.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fscala2.instructions.md) | Scala 2.12/2.13 programming language coding conventions and best practices following Databricks style guide for functional programming, type safety, and production code quality. |
 | [Secure Coding and OWASP Guidelines](../instructions/security-and-owasp.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fsecurity-and-owasp.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fsecurity-and-owasp.instructions.md) | Comprehensive secure coding instructions for all languages and frameworks, based on OWASP Top 10 and industry best practices. |
 | [Self-explanatory Code Commenting Instructions](../instructions/self-explanatory-code-commenting.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fself-explanatory-code-commenting.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fself-explanatory-code-commenting.instructions.md) | Guidelines for GitHub Copilot to write comments to achieve self-explanatory code with less comments. Examples are in JavaScript but it should work on any language that has comments. |
 | [Shell Scripting Guidelines](../instructions/shell.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fshell.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fshell.instructions.md) | Shell scripting best practices and conventions for bash, sh, zsh, and other shells |
@@ -152,6 +154,7 @@ Team and project-specific instructions to enhance GitHub Copilot's behavior for
 | [Style Components with Modern Theming (Preview)](../instructions/pcf-fluent-modern-theming.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-fluent-modern-theming.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-fluent-modern-theming.instructions.md) | Style components with modern theming using Fluent UI |
 | [Svelte 5 and SvelteKit Development Instructions](../instructions/svelte.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fsvelte.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fsvelte.instructions.md) | Svelte 5 and SvelteKit development standards and best practices for component-based user interfaces and full-stack applications |
 | [Swift MCP Server Development Guidelines](../instructions/swift-mcp-server.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fswift-mcp-server.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fswift-mcp-server.instructions.md) | Best practices and patterns for building Model Context Protocol (MCP) servers in Swift using the official MCP Swift SDK package. |
 | [Symfony Development Instructions](../instructions/php-symfony.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fphp-symfony.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fphp-symfony.instructions.md) | Symfony development standards aligned with official Symfony Best Practices |
 | [Taming Copilot](../instructions/taming-copilot.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftaming-copilot.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftaming-copilot.instructions.md) | Prevent Copilot from wreaking havoc across your codebase, keeping it under control. |
 | [TanStack Start with Shadcn/ui Development Guide](../instructions/tanstack-start-shadcn-tailwind.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftanstack-start-shadcn-tailwind.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftanstack-start-shadcn-tailwind.instructions.md) | Guidelines for building TanStack Start applications |
 | [Task Plan Implementation Instructions](../instructions/task-implementation.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftask-implementation.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Ftask-implementation.instructions.md) | Instructions for implementing task plans with progressive tracking and change record - Brought to you by microsoft/edge-ai |
@@ -165,5 +168,6 @@ Team and project-specific instructions to enhance GitHub Copilot's behavior for
 | [Update Documentation on Code Change](../instructions/update-docs-on-code-change.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fupdate-docs-on-code-change.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fupdate-docs-on-code-change.instructions.md) | Automatically update README.md and documentation files when application code changes require documentation updates |
 | [Upgrading from .NET MAUI 9 to .NET MAUI 10](../instructions/dotnet-maui-9-to-dotnet-maui-10-upgrade.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fdotnet-maui-9-to-dotnet-maui-10-upgrade.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fdotnet-maui-9-to-dotnet-maui-10-upgrade.instructions.md) | Instructions for upgrading .NET MAUI applications from version 9 to version 10, including breaking changes, deprecated APIs, and migration strategies for ListView to CollectionView. |
 | [Use Code Components in Power Pages](../instructions/pcf-power-pages.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-power-pages.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpcf-power-pages.instructions.md) | Using code components in Power Pages sites |
 | [Visual Studio Extension Development with Community.VisualStudio.Toolkit](../instructions/vsixtoolkit.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fvsixtoolkit.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fvsixtoolkit.instructions.md) | Guidelines for Visual Studio extension (VSIX) development using Community.VisualStudio.Toolkit |
 | [VueJS 3 Development Instructions](../instructions/vuejs3.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fvuejs3.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fvuejs3.instructions.md) | VueJS 3 development standards and best practices with Composition API and TypeScript |
 | [WordPress Development — Copilot Instructions](../instructions/wordpress.instructions.md)<br />[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fwordpress.instructions.md)<br />[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fwordpress.instructions.md) | Coding, security, and testing rules for WordPress plugins and themes |
--- a/instructions/lwc.instructions.md
+++ b/instructions/lwc.instructions.md
@@ -0,0 +1,426 @@
 ---
 description: 'Guidelines and best practices for developing Lightning Web Components (LWC) on Salesforce Platform.'
 applyTo: 'force-app/main/default/lwc/**'
 ---
 # LWC Development
 ## General Instructions
 - Each LWC should reside in its own folder under `force-app/main/default/lwc/`.
 - The folder name should match the component name (e.g., `myComponent` folder for the `myComponent` component).
 - Each component folder should contain the following files:
    - `myComponent.html`: The HTML template file.
    - `myComponent.js`: The JavaScript controller file.
    - `myComponent.js-meta.xml`: The metadata configuration file.
    - Optional: `myComponent.css` for component-specific styles.
    - Optional: `myComponent.test.js` for Jest unit tests.
 ## Core Principles
 ### 1. Use Lightning Components Over HTML Tags
 Always prefer Lightning Web Component library components over plain HTML elements for consistency, accessibility, and future-proofing.
 #### Recommended Approach
 ```html
 <!-- Use Lightning components -->
 <lightning-button label="Save" variant="brand" onclick={handleSave}></lightning-button>
 <lightning-input type="text" label="Name" value={name} onchange={handleNameChange}></lightning-input>
 <lightning-combobox label="Type" options={typeOptions} value={selectedType}></lightning-combobox>
 <lightning-radio-group name="duration" label="Duration" options={durationOptions} value={duration} type="radio"></lightning-radio-group>
 ```
 #### Avoid Plain HTML
 ```html
 <!-- Avoid these -->
 <button onclick={handleSave}>Save</button>
 <input type="text" onchange={handleNameChange} />
 <select onchange={handleTypeChange}>
    <option value="option1">Option 1</option>
 </select>
 ```
 ### 2. Lightning Component Mapping Guide
 | HTML Element | Lightning Component | Key Attributes |
 |--------------|-------------------|----------------|
 | `<button>` | `<lightning-button>` | `variant`, `label`, `icon-name` |
 | `<input>` | `<lightning-input>` | `type`, `label`, `variant` |
 | `<select>` | `<lightning-combobox>` | `options`, `value`, `placeholder` |
 | `<textarea>` | `<lightning-textarea>` | `label`, `max-length` |
 | `<input type="checkbox">` | `<lightning-input type="checkbox">` | `checked`, `label` |
 | `<input type="radio">` | `<lightning-radio-group>` | `options`, `type`, `name` |
 | `<input type="toggle">` | `<lightning-input type="toggle">` | `checked`, `variant` |
 | Custom pills | `<lightning-pill>` | `label`, `name`, `onremove` |
 | Icons | `<lightning-icon>` | `icon-name`, `size`, `variant` |
 ### 3. Lightning Design System Compliance
 #### Use SLDS Utility Classes
 Always use Salesforce Lightning Design System utility classes with the `slds-var-` prefix for modern implementations:
 ```html
 <!-- Spacing -->
 <div class="slds-var-m-around_medium slds-var-p-top_large">
    <div class="slds-var-m-bottom_small">Content</div>
 </div>
 <!-- Layout -->
 <div class="slds-grid slds-wrap slds-gutters_small">
    <div class="slds-col slds-size_1-of-2 slds-medium-size_1-of-3">
        <!-- Content -->
    </div>
 </div>
 <!-- Typography -->
 <h2 class="slds-text-heading_medium slds-var-m-bottom_small">Section Title</h2>
 <p class="slds-text-body_regular">Description text</p>
 ```
 #### SLDS Component Patterns
 ```html
 <!-- Card Layout -->
 <article class="slds-card slds-var-m-around_medium">
    <header class="slds-card__header">
        <h2 class="slds-text-heading_small">Card Title</h2>
    </header>
    <div class="slds-card__body slds-card__body_inner">
        <!-- Card content -->
    </div>
    <footer class="slds-card__footer">
        <!-- Card actions -->
    </footer>
 </article>
 <!-- Form Layout -->
 <div class="slds-form slds-form_stacked">
    <div class="slds-form-element">
        <lightning-input label="Field Label" value={fieldValue}></lightning-input>
    </div>
 </div>
 ```
 ### 4. Avoid Custom CSS
 #### Use SLDS Classes
 ```html
 <!-- Color and theming -->
 <div class="slds-theme_success slds-text-color_inverse slds-var-p-around_small">
    Success message
 </div>
 <div class="slds-theme_error slds-text-color_inverse slds-var-p-around_small">
    Error message
 </div>
 <div class="slds-theme_warning slds-text-color_inverse slds-var-p-around_small">
    Warning message
 </div>
 ```
 #### Avoid Custom CSS (Anti-Pattern)
 ```css
 /* Don't create custom styles that override SLDS */
 .custom-button {
    background-color: red;
    padding: 10px;
 }
 .my-special-layout {
    display: flex;
    justify-content: center;
 }
 ```
 #### When Custom CSS is Necessary
 If you must use custom CSS, follow these guidelines:
 - Use CSS custom properties (design tokens) when possible
 - Prefix custom classes to avoid conflicts
 - Never override SLDS base classes
 ```css
 /* Custom CSS example */
 .my-component-special {
    border-radius: var(--lwc-borderRadiusMedium);
    box-shadow: var(--lwc-shadowButton);
 }
 ```
 ### 5. Component Architecture Best Practices
 #### Reactive Properties
 ```javascript
 import { LightningElement, track, api } from 'lwc';
 export default class MyComponent extends LightningElement {
    // Use @api for public properties
    @api recordId;
    @api title;
    // Primitive properties (string, number, boolean) are automatically reactive
    // No decorator needed - reassignment triggers re-render
    simpleValue = 'initial';
    count = 0;
    // Computed properties
    get displayName() {
        return this.name ? `Hello, ${this.name}` : 'Hello, Guest';
    }
    // @track is NOT needed for simple property reassignment
    // This will trigger reactivity automatically:
    handleUpdate() {
        this.simpleValue = 'updated'; // Reactive without @track
        this.count++; // Reactive without @track
    }
    // @track IS needed when mutating nested properties without reassignment
    @track complexData = {
        user: {
            name: 'John',
            preferences: {
                theme: 'dark'
            }
        }
    };
    handleDeepUpdate() {
        // Requires @track because we're mutating a nested property
        this.complexData.user.preferences.theme = 'light';
    }
    // BETTER: Avoid @track by using immutable patterns
    regularData = {
        user: {
            name: 'John',
            preferences: {
                theme: 'dark'
            }
        }
    };
    handleImmutableUpdate() {
      // No @track needed - we're creating a new object reference
      this.regularData = {
        ...this.regularData,
        user: {
          ...this.regularData.user,
          preferences: {
            ...this.regularData.user.preferences,
            theme: 'light'
          }
        }
      };
    }
    // Arrays: @track is needed only for mutating methods
    @track items = ['a', 'b', 'c'];
    handleArrayMutation() {
      // Requires @track
      this.items.push('d');
      this.items[0] = 'z';
    }
    // BETTER: Use immutable array operations
    regularItems = ['a', 'b', 'c'];
    handleImmutableArray() {
      // No @track needed
      this.regularItems = [...this.regularItems, 'd'];
      this.regularItems = this.regularItems.map((item, idx) =>
        idx === 0 ? 'z' : item
      );
    }
    // Use @track only for complex objects/arrays when you mutate nested properties.
    // For example, updating complexObject.details.status without reassigning complexObject.
    @track complexObject = {
      details: {
        status: 'new'
      }
    };
 }
 ```
 #### Event Handling Patterns
 ```javascript
 // Custom event dispatch
 handleSave() {
    const saveEvent = new CustomEvent('save', {
        detail: {
            recordData: this.recordData,
            timestamp: new Date()
        }
    });
    this.dispatchEvent(saveEvent);
 }
 // Lightning component event handling
 handleInputChange(event) {
    const fieldName = event.target.name;
    const fieldValue = event.target.value;
    // For lightning-input, lightning-combobox, etc.
    this[fieldName] = fieldValue;
 }
 handleRadioChange(event) {
    // For lightning-radio-group
    this.selectedValue = event.detail.value;
 }
 handleToggleChange(event) {
    // For lightning-input type="toggle"
    this.isToggled = event.detail.checked;
 }
 ```
 ### 6. Data Handling and Wire Services
 #### Use @wire for Data Access
 ```javascript
 import { getRecord } from 'lightning/uiRecordApi';
 import { getObjectInfo } from 'lightning/uiObjectInfoApi';
 const FIELDS = ['Account.Name', 'Account.Industry', 'Account.AnnualRevenue'];
 export default class MyComponent extends LightningElement {
    @api recordId;
    @wire(getRecord, { recordId: '$recordId', fields: FIELDS })
    record;
    @wire(getObjectInfo, { objectApiName: 'Account' })
    objectInfo;
    get recordData() {
        return this.record.data ? this.record.data.fields : {};
    }
 }
 ```
 ### 7. Error Handling and User Experience
 #### Implement Proper Error Boundaries
 ```javascript
 import { ShowToastEvent } from 'lightning/platformShowToastEvent';
 export default class MyComponent extends LightningElement {
    isLoading = false;
    error = null;
    async handleAsyncOperation() {
        this.isLoading = true;
        this.error = null;
        try {
            const result = await this.performOperation();
            this.showSuccessToast();
        } catch (error) {
            this.error = error;
            this.showErrorToast(error.body?.message || 'An error occurred');
        } finally {
            this.isLoading = false;
        }
    }
    performOperation() {
        // Developer-defined async operation
    }
    showSuccessToast() {
        const event = new ShowToastEvent({
            title: 'Success',
            message: 'Operation completed successfully',
            variant: 'success'
        });
        this.dispatchEvent(event);
    }
    showErrorToast(message) {
        const event = new ShowToastEvent({
            title: 'Error',
            message: message,
            variant: 'error',
            mode: 'sticky'
        });
        this.dispatchEvent(event);
    }
 }
 ```
 ### 8. Performance Optimization
 #### Conditional Rendering
 Prefer `lwc:if`, `lwc:elseif` and `lwc:else` for conditional rendering (API v58.0+). Legacy `if:true` / `if:false` are still supported but should be avoided in new components.
 ```html
 <!-- Use template directives for conditional rendering -->
 <template lwc:if={isLoading}>
    <lightning-spinner alternative-text="Loading..."></lightning-spinner>
 </template>
 <template lwc:elseif={error}>
    <div class="slds-theme_error slds-text-color_inverse slds-var-p-around_small">
        {error.message}
    </div>
 </template>
 <template lwc:else>
    <template for:each={items} for:item="item">
        <div key={item.id} class="slds-var-m-bottom_small">
            {item.name}
        </div>
    </template>
 </template>
 ```
 ```html
 <!-- Legacy approach (avoid in new components) -->
 <template if:true={isLoading}>
    <lightning-spinner alternative-text="Loading..."></lightning-spinner>
 </template>
 <template if:true={error}>
    <div class="slds-theme_error slds-text-color_inverse slds-var-p-around_small">
        {error.message}
    </div>
 </template>
 <template if:false={isLoading}>
  <template if:false={error}>
    <template for:each={items} for:item="item">
        <div key={item.id} class="slds-var-m-bottom_small">
            {item.name}
        </div>
    </template>
  </template>
 </template>
 ```
 ### 9. Accessibility Best Practices
 #### Use Proper ARIA Labels and Semantic HTML
 ```html
 <!-- Use semantic structure -->
 <section aria-label="Product Selection">
    <h2 class="slds-text-heading_medium">Products</h2>
    <lightning-input
        type="search"
        label="Search Products"
        placeholder="Enter product name..."
        aria-describedby="search-help">
    </lightning-input>
    <div id="search-help" class="slds-assistive-text">
        Type to filter the product list
    </div>
 </section>
 ```
 ## Common Anti-Patterns to Avoid
 - **Direct DOM Manipulation**: Never use `document.querySelector()` or similar
 - **jQuery or External Libraries**: Avoid non-Lightning compatible libraries
 - **Inline Styles**: Use SLDS classes instead of `style` attributes
 - **Global CSS**: All styles should be scoped to the component
 - **Hardcoded Values**: Use custom labels, custom metadata, or constants
 - **Imperative API Calls**: Prefer `@wire` over imperative `import` calls when possible
 - **Memory Leaks**: Always clean up event listeners in `disconnectedCallback()`
--- a/instructions/php-symfony.instructions.md
+++ b/instructions/php-symfony.instructions.md
@@ -0,0 +1,122 @@
 ---
 description: "Symfony development standards aligned with official Symfony Best Practices"
 applyTo: "**/*.php, **/*.yaml, **/*.yml, **/*.xml, **/*.twig"
 ---
 # Symfony Development Instructions
 Instructions for developing Symfony applications following the official Symfony Best Practices and core framework philosophy.
 ## Project Context
 - Symfony (latest stable or LTS)
 - Default Symfony directory structure
 - Autowiring and autoconfiguration enabled
 - Doctrine ORM when persistence is needed
 - Twig for templating
 - Symfony Forms, Validator, Security, Messenger as needed
 - PHPUnit for testing
 - Attribute-based configuration where supported
 ## Project Structure
 - Use the default Symfony directory structure
 - Do not create bundles for application code
 - Organize application code using PHP namespaces
 - Keep configuration in `config/`, application code in `src/`, templates in `templates/`
 ## Configuration
 ### Environment Configuration
 - Use environment variables for infrastructure-related configuration
 - Use `.env` files to define environment-specific values
 - Do not use environment variables to control application behavior
 ### Sensitive Configuration
 - Store secrets (API keys, credentials) using Symfony Secrets
 - Never commit secrets to the repository
 ### Application Configuration
 - Use parameters in `config/services.yaml` for application behavior configuration
 - Override parameters per environment only when needed
 - Prefix parameters with `app.` to avoid collisions
 - Use short, descriptive parameter names
 - Use PHP constants for configuration values that rarely change
 ## Services & Dependency Injection
 - Use dependency injection exclusively
 - Prefer constructor injection
 - Use autowiring and autoconfiguration by default
 - Keep services private whenever possible
 - Avoid accessing services via `$container->get()`
 - Use YAML as the preferred format for service configuration
 - Use interfaces where it improves decoupling or clarity
 ## Controllers
 - Extend `AbstractController`
 - Keep controllers thin and focused on glue code
 - Do not place business logic in controllers
 - Use attributes to configure routing, caching, and security
 - Use dependency injection for services
 - Use Entity Value Resolvers when convenient and appropriate
 - Perform complex queries explicitly via repositories when needed
 ## Doctrine & Persistence
 - Use Doctrine entities as plain PHP objects
 - Define Doctrine mapping using PHP attributes
 - Use repositories for querying data
 - Avoid putting business logic in repositories
 - Use migrations for all schema changes
 ## Templates (Twig)
 - Use snake_case for template names, directories, and variables
 - Prefix template fragments with an underscore
 - Keep templates focused on presentation
 - Avoid business logic in Twig templates
 - Escape output by default
 - Avoid using `|raw` unless content is trusted and sanitized
 ## Forms
 - Define forms as PHP classes
 - Do not build forms directly in controllers
 - Add form buttons in templates, not in form classes
 - Define validation constraints on the underlying object
 - Use a single controller action to render and process each form
 - Define submit buttons in controllers only when multiple submits are required
 ## Validation
 - Use Symfony Validator constraints
 - Validate data at application boundaries
 - Prefer object-level validation over form-only validation when reuse is needed
 ## Internationalization
 - Use XLIFF for translation files
 - Use translation keys instead of literal content strings
 - Use descriptive keys that express purpose, not location
 ## Security
 - Prefer a single firewall unless multiple systems are required
 - Use the auto password hasher
 - Use voters for complex authorization logic
 - Avoid complex security expressions in attributes
 ## Web Assets
 - Use AssetMapper to manage web assets
 - Avoid unnecessary frontend build complexity unless required
 ## Asynchronous Processing
 - Use Symfony Messenger for async and background tasks
 - Keep message handlers small and focused
 - Configure failure transports for failed messages
 ## Testing
 - Write functional tests using `WebTestCase`
 - Add smoke tests to ensure all public URLs respond successfully
 - Hard-code URLs in functional tests instead of generating routes
 - Use unit tests where appropriate for isolated logic
 - Add more specific tests incrementally as the application evolves
 ## General Guidelines
 - Prefer clarity over abstraction
 - Follow Symfony conventions before introducing custom patterns
 - Keep configuration explicit and readable
 - Avoid premature optimization
 - Use Symfony Demo as a reference implementation
--- a/instructions/scala2.instructions.md
+++ b/instructions/scala2.instructions.md
@@ -0,0 +1,834 @@
 ---
 description: 'Scala 2.12/2.13 programming language coding conventions and best practices following Databricks style guide for functional programming, type safety, and production code quality.'
 applyTo: '**.scala, **/build.sbt, **/build.sc'
 ---
 # Scala Best Practices
 Based on the [Databricks Scala Style Guide](https://github.com/databricks/scala-style-guide)
 ## Core Principles
 ### Write Simple Code
 Code is written once but read and modified multiple times. Optimize for long-term readability and maintainability by writing simple code.
 ### Immutability by Default
 - Always prefer `val` over `var`
 - Use immutable collections from `scala.collection.immutable`
 - Case class constructor parameters should NOT be mutable
 - Use copy constructor to create modified instances
 ```scala
 // Good - Immutable case class
 case class Person(name: String, age: Int)
 // Bad - Mutable case class
 case class Person(name: String, var age: Int)
 // To change values, use copy constructor
 val p1 = Person("Peter", 15)
 val p2 = p1.copy(age = 16)
 // Good - Immutable collections
 val users = List(User("Alice", 30), User("Bob", 25))
 val updatedUsers = users.map(u => u.copy(age = u.age + 1))
 ```
 ### Pure Functions
 - Functions should be deterministic and side-effect free
 - Separate pure logic from effects
 - Use explicit types for methods with effects
 ```scala
 // Good - Pure function
 def calculateTotal(items: List[Item]): BigDecimal =
  items.map(_.price).sum
 // Bad - Impure function with side effects
 def calculateTotal(items: List[Item]): BigDecimal = {
  println(s"Calculating total for ${items.size} items")  // Side effect
  val total = items.map(_.price).sum
  saveToDatabase(total)  // Side effect
  total
 }
 ```
 ## Naming Conventions
 ### Classes and Objects
 ```scala
 // Classes, traits, objects - PascalCase
 class ClusterManager
 trait Expression
 object Configuration
 // Packages - all lowercase ASCII
 package com.databricks.resourcemanager
 // Methods/functions - camelCase
 def getUserById(id: Long): Option[User]
 def processData(input: String): Result
 // Constants - uppercase in companion object
 object Configuration {
  val DEFAULT_PORT = 10000
  val MAX_RETRIES = 3
  val TIMEOUT_MS = 5000L
 }
 ```
 ### Variables and Parameters
 ```scala
 // Variables - camelCase, self-evident names
 val serverPort = 1000
 val clientPort = 2000
 val maxRetryAttempts = 3
 // One-character names OK in small, localized scope
 for (i <- 0 until 10) {
  // ...
 }
 // Do NOT use "l" (Larry) - looks like "1", "|", "I"
 ```
 ### Enumerations
 ```scala
 // Enumeration object - PascalCase
 // Values - UPPER_CASE with underscores
 private object ParseState extends Enumeration {
  type ParseState = Value
  val PREFIX,
      TRIM_BEFORE_SIGN,
      SIGN,
      VALUE,
      UNIT_BEGIN,
      UNIT_END = Value
 }
 ```
 ## Syntactic Style
 ### Line Length and Spacing
 ```scala
 // Limit lines to 100 characters
 // One space before and after operators
 def add(int1: Int, int2: Int): Int = int1 + int2
 // One space after commas
 val list = List("a", "b", "c")
 // One space after colons
 def getConf(key: String, defaultValue: String): String = {
  // code
 }
 // Use 2-space indentation
 if (true) {
  println("Wow!")
 }
 // 4-space indentation for long parameter lists
 def newAPIHadoopFile[K, V, F <: NewInputFormat[K, V]](
    path: String,
    fClass: Class[F],
    kClass: Class[K],
    vClass: Class[V],
    conf: Configuration = hadoopConfiguration): RDD[(K, V)] = {
  // method body
 }
 // Class with long parameters
 class Foo(
    val param1: String,  // 4 space indent
    val param2: String,
    val param3: Array[Byte])
  extends FooInterface  // 2 space indent
  with Logging {
  def firstMethod(): Unit = { ... }  // blank line above
 }
 ```
 ### Rule of 30
 - A method should contain less than 30 lines of code
 - A class should contain less than 30 methods
 ### Curly Braces
 ```scala
 // Always use curly braces for multi-line blocks
 if (true) {
  println("Wow!")
 }
 // Exception: one-line ternary (side-effect free)
 val result = if (condition) value1 else value2
 // Always use braces for try-catch
 try {
  foo()
 } catch {
  case e: Exception => handle(e)
 }
 ```
 ### Long Literals
 ```scala
 // Use uppercase L for long literals
 val longValue = 5432L  // Do this
 val badValue = 5432l   // Don't do this - hard to see
 ```
 ### Parentheses
 ```scala
 // Methods with side-effects - use parentheses
 class Job {
  def killJob(): Unit = { ... }  // Correct - changes state
  def getStatus: JobStatus = { ... }  // Correct - no side-effect
 }
 // Callsite should match declaration
 new Job().killJob()  // Correct
 new Job().getStatus  // Correct
 ```
 ### Imports
 ```scala
 // Avoid wildcard imports unless importing 6+ entities
 import scala.collection.mutable.{Map, HashMap, ArrayBuffer}
 // OK to use wildcard for implicits or 6+ items
 import scala.collection.JavaConverters._
 import java.util.{Map, HashMap, List, ArrayList, Set, HashSet}
 // Always use absolute paths
 import scala.util.Random  // Good
 // import util.Random     // Don't use relative
 // Import order (with blank lines):
 import java.io.File
 import javax.servlet.http.HttpServlet
 import scala.collection.mutable.HashMap
 import scala.util.Random
 import org.apache.spark.SparkContext
 import org.apache.spark.rdd.RDD
 import com.databricks.MyClass
 ```
 ### Pattern Matching
 ```scala
 // Put match on same line if method is entirely pattern match
 def test(msg: Message): Unit = msg match {
  case TextMessage(text) => handleText(text)
  case ImageMessage(url) => handleImage(url)
 }
 // Single case closures - same line
 list.zipWithIndex.map { case (elem, i) =>
  // process
 }
 // Multiple cases - indent and wrap
 list.map {
  case a: Foo => processFoo(a)
  case b: Bar => processBar(b)
  case _ => handleDefault()
 }
 // Match on type only - don't expand all args
 case class Pokemon(name: String, weight: Int, hp: Int, attack: Int, defense: Int)
 // Bad - brittle when fields change
 targets.foreach {
  case Pokemon(_, _, hp, _, defense) =>
    // error prone
 }
 // Good - match on type
 targets.foreach {
  case p: Pokemon =>
    val loss = math.min(0, myAttack - p.defense)
    p.copy(hp = p.hp - loss)
 }
 ```
 ### Anonymous Functions
 ```scala
 // Avoid excessive parentheses
 // Correct
 list.map { item =>
  transform(item)
 }
 // Correct
 list.map(item => transform(item))
 // Wrong - unnecessary braces
 list.map(item => {
  transform(item)
 })
 // Wrong - excessive nesting
 list.map({ item => ... })
 ```
 ### Infix Methods
 ```scala
 // Avoid infix for non-symbolic methods
 list.map(func)  // Correct
 list map func   // Wrong
 // OK for operators
 arrayBuffer += elem
 ```
 ## Language Features
 ### Avoid apply() on Classes
 ```scala
 // Avoid apply on classes - hard to trace
 class TreeNode {
  def apply(name: String): TreeNode = { ... }  // Don't do this
 }
 // OK on companion objects as factory
 object TreeNode {
  def apply(name: String): TreeNode = new TreeNode(name)  // OK
 }
 ```
 ### override Modifier
 ```scala
 // Always use override - even for abstract methods
 trait Parent {
  def hello(data: Map[String, String]): Unit
 }
 class Child extends Parent {
  // Without override, this might not actually override!
  override def hello(data: Map[String, String]): Unit = {
    println(data)
  }
 }
 ```
 ### Avoid Destructuring in Constructors
 ```scala
 // Don't use destructuring binds in constructors
 class MyClass {
  // Bad - creates non-transient Tuple2
  @transient private val (a, b) = someFuncThatReturnsTuple2()
  // Good
  @transient private val tuple = someFuncThatReturnsTuple2()
  @transient private val a = tuple._1
  @transient private val b = tuple._2
 }
 ```
 ### Avoid Call-by-Name
 ```scala
 // Avoid call-by-name parameters
 // Bad - caller can't tell if executed once or many times
 def print(value: => Int): Unit = {
  println(value)
  println(value + 1)
 }
 // Good - explicit function type
 def print(value: () => Int): Unit = {
  println(value())
  println(value() + 1)
 }
 ```
 ### Avoid Multiple Parameter Lists
 ```scala
 // Avoid multiple parameter lists (except for implicits)
 // Bad
 case class Person(name: String, age: Int)(secret: String)
 // Good
 case class Person(name: String, age: Int, secret: String)
 // Exception: separate list for implicits (but avoid implicits!)
 def foo(x: Int)(implicit ec: ExecutionContext): Future[Int]
 ```
 ### Symbolic Methods
 ```scala
 // Only use for arithmetic operators
 class Vector {
  def +(other: Vector): Vector = { ... }  // OK
  def -(other: Vector): Vector = { ... }  // OK
 }
 // Don't use for other methods
 // Bad
 channel ! msg
 stream1 >>= stream2
 // Good
 channel.send(msg)
 stream1.join(stream2)
 ```
 ### Type Inference
 ```scala
 // Always type public methods
 def getUserById(id: Long): Option[User] = { ... }
 // Always type implicit methods
 implicit def stringToInt(s: String): Int = s.toInt
 // Type variables when not obvious (3 second rule)
 val user: User = complexComputation()
 // OK to omit when obvious
 val count = 5
 val name = "Alice"
 ```
 ### Return Statements
 ```scala
 // Avoid return in closures - uses exceptions under the hood
 def receive(rpc: WebSocketRPC): Option[Response] = {
  tableFut.onComplete { table =>
    if (table.isFailure) {
      return None  // Don't do this - wrong thread!
    }
  }
 }
 // Use return as guard to simplify control flow
 def doSomething(obj: Any): Any = {
  if (obj eq null) {
    return null
  }
  // do something
 }
 // Use return to break loops early
 while (true) {
  if (cond) {
    return
  }
 }
 ```
 ### Recursion and Tail Recursion
 ```scala
 // Avoid recursion unless naturally recursive (trees, graphs)
 // Use @tailrec for tail-recursive methods
@scala.annotation.tailrec
 def max0(data: Array[Int], pos: Int, max: Int): Int = {
  if (pos == data.length) {
    max
  } else {
    max0(data, pos + 1, if (data(pos) > max) data(pos) else max)
  }
 }
 // Prefer explicit loops for clarity
 def max(data: Array[Int]): Int = {
  var max = Int.MinValue
  for (v <- data) {
    if (v > max) {
      max = v
    }
  }
  max
 }
 ```
 ### Implicits
 ```scala
 // Avoid implicits unless:
 // 1. Building a DSL
 // 2. Implicit type parameters (ClassTag, TypeTag)
 // 3. Private type conversions within your class
 // If you must use them, don't overload
 object ImplicitHolder {
  // Bad - can't selectively import
  def toRdd(seq: Seq[Int]): RDD[Int] = { ... }
  def toRdd(seq: Seq[Long]): RDD[Long] = { ... }
 }
 // Good - distinct names
 object ImplicitHolder {
  def intSeqToRdd(seq: Seq[Int]): RDD[Int] = { ... }
  def longSeqToRdd(seq: Seq[Long]): RDD[Long] = { ... }
 }
 ```
 ## Type Safety
 ### Algebraic Data Types
 ```scala
 // Sum types - sealed traits with case classes
 sealed trait PaymentMethod
 case class CreditCard(number: String, cvv: String) extends PaymentMethod
 case class PayPal(email: String) extends PaymentMethod
 case class BankTransfer(account: String, routing: String) extends PaymentMethod
 def processPayment(payment: PaymentMethod): Either[Error, Receipt] = payment match {
  case CreditCard(number, cvv) => chargeCreditCard(number, cvv)
  case PayPal(email) => chargePayPal(email)
  case BankTransfer(account, routing) => chargeBankAccount(account, routing)
 }
 // Product types - case classes
 case class User(id: Long, name: String, email: String, age: Int)
 case class Order(id: Long, userId: Long, items: List[Item], total: BigDecimal)
 ```
 ### Option over null
 ```scala
 // Use Option instead of null
 def findUserById(id: Long): Option[User] = {
  database.query(id)
 }
 // Use Option() to guard against nulls
 def myMethod1(input: String): Option[String] = Option(transform(input))
 // Don't use Some() - it won't protect against null
 def myMethod2(input: String): Option[String] = Some(transform(input)) // Bad
 // Pattern matching on Option
 def processUser(id: Long): String = findUserById(id) match {
  case Some(user) => s"Found: ${user.name}"
  case None => "User not found"
 }
 // Don't call get() unless absolutely sure
 val user = findUserById(123).get  // Dangerous!
 // Use getOrElse, map, flatMap, fold instead
 val name = findUserById(123).map(_.name).getOrElse("Unknown")
 ```
 ### Error Handling with Either
 ```scala
 sealed trait ValidationError
 case class InvalidEmail(email: String) extends ValidationError
 case class InvalidAge(age: Int) extends ValidationError
 case class MissingField(field: String) extends ValidationError
 def validateUser(data: Map[String, String]): Either[ValidationError, User] = {
  for {
    name <- data.get("name").toRight(MissingField("name"))
    email <- data.get("email").toRight(MissingField("email"))
    validEmail <- validateEmail(email)
    ageStr <- data.get("age").toRight(MissingField("age"))
    age <- ageStr.toIntOption.toRight(InvalidAge(-1))
  } yield User(name, validEmail, age)
 }
 ```
 ### Try vs Exceptions
 ```scala
 // Don't return Try from APIs
 // Bad
 def getUser(id: Long): Try[User]
 // Good - explicit throws
@throws(classOf[DatabaseConnectionException])
 def getUser(id: Long): Option[User]
 // Use NonFatal for catching exceptions
 import scala.util.control.NonFatal
 try {
  dangerousOperation()
 } catch {
  case NonFatal(e) =>
    logger.error("Operation failed", e)
  case e: InterruptedException =>
    // handle interruption
 }
 ```
 ## Collections
 ### Prefer Immutable Collections
 ```scala
 import scala.collection.immutable._
 // Good
 val numbers = List(1, 2, 3, 4, 5)
 val doubled = numbers.map(_ * 2)
 val evens = numbers.filter(_ % 2 == 0)
 val userMap = Map(
  1L -> "Alice",
  2L -> "Bob"
 )
 val updated = userMap + (3L -> "Charlie")
 // Use Stream (Scala 2.12) or LazyList (Scala 2.13) for lazy sequences
 val fibonacci: LazyList[BigInt] =
  BigInt(0) #:: BigInt(1) #:: fibonacci.zip(fibonacci.tail).map { case (a, b) => a + b }
 val first10 = fibonacci.take(10).toList
 ```
 ### Monadic Chaining
 ```scala
 // Avoid chaining more than 3 operations
 // Break after flatMap
 // Don't chain with if-else blocks
 // Bad - too complex
 database.get(name).flatMap { elem =>
  elem.data.get("address").flatMap(Option.apply)
 }
 // Good - more readable
 def getAddress(name: String): Option[String] = {
  if (!database.contains(name)) {
    return None
  }
  database(name).data.get("address") match {
    case Some(null) => None
    case Some(addr) => Option(addr)
    case None => None
  }
 }
 // Don't chain with if-else
 // Bad
 if (condition) {
  Seq(1, 2, 3)
 } else {
  Seq(1, 2, 3)
 }.map(_ + 1)
 // Good
 val seq = if (condition) Seq(1, 2, 3) else Seq(4, 5, 6)
 seq.map(_ + 1)
 ```
 ## Performance
 ### Use while Loops
 ```scala
 // For performance-critical code, use while instead of for/map
 val arr = Array.fill(1000)(Random.nextInt())
 // Slow
 val newArr = arr.zipWithIndex.map { case (elem, i) =>
  if (i % 2 == 0) 0 else elem
 }
 // Fast
 val newArr = new Array[Int](arr.length)
 var i = 0
 while (i < arr.length) {
  newArr(i) = if (i % 2 == 0) 0 else arr(i)
  i += 1
 }
 ```
 ### Option vs null
 ```scala
 // For performance-critical code, prefer null over Option
 class Foo {
  @javax.annotation.Nullable
  private[this] var nullableField: Bar = _
 }
 ```
 ### Use private[this]
 ```scala
 // private[this] generates fields, not accessor methods
 class MyClass {
  private val field1 = ...        // Might use accessor
  private[this] val field2 = ...  // Direct field access
  def perfSensitiveMethod(): Unit = {
    var i = 0
    while (i < 1000000) {
      field2  // Guaranteed field access
      i += 1
    }
  }
 }
 ```
 ### Java Collections
 ```scala
 // For performance, prefer Java collections
 import java.util.{ArrayList, HashMap}
 val list = new ArrayList[String]()
 val map = new HashMap[String, Int]()
 ```
 ## Concurrency
 ### Prefer ConcurrentHashMap
 ```scala
 // Use java.util.concurrent.ConcurrentHashMap
 private[this] val map = new java.util.concurrent.ConcurrentHashMap[String, String]
 // Or synchronized map for low contention
 private[this] val map = java.util.Collections.synchronizedMap(
  new java.util.HashMap[String, String]
 )
 ```
 ### Explicit Synchronization
 ```scala
 class Manager {
  private[this] var count = 0
  private[this] val map = new java.util.HashMap[String, String]
  def update(key: String, value: String): Unit = synchronized {
    map.put(key, value)
    count += 1
  }
  def getCount: Int = synchronized { count }
 }
 ```
 ### Atomic Variables
 ```scala
 import java.util.concurrent.atomic._
 // Prefer Atomic over @volatile
 val initialized = new AtomicBoolean(false)
 // Clearly express only-once execution
 if (!initialized.getAndSet(true)) {
  initialize()
 }
 ```
 ## Testing
 ### Intercept Specific Exceptions
 ```scala
 import org.scalatest._
 // Bad - too broad
 intercept[Exception] {
  thingThatThrows()
 }
 // Good - specific type
 intercept[IllegalArgumentException] {
  thingThatThrows()
 }
 ```
 ## SBT Configuration
 ```scala
 // build.sbt
 ThisBuild / version := "0.1.0-SNAPSHOT"
 ThisBuild / scalaVersion := "2.13.12"
 ThisBuild / organization := "com.example"
 lazy val root = (project in file("."))
  .settings(
    name := "my-application",
    libraryDependencies ++= Seq(
      "org.typelevel" %% "cats-core" % "2.10.0",
      "org.typelevel" %% "cats-effect" % "3.5.2",
      // Testing
      "org.scalatest" %% "scalatest" % "3.2.17" % Test,
      "org.scalatestplus" %% "scalacheck-1-17" % "3.2.17.0" % Test
    ),
    scalacOptions ++= Seq(
      "-encoding", "UTF-8",
      "-feature",
      "-unchecked",
      "-deprecation",
      "-Xfatal-warnings"
    )
  )
 ```
 ## Miscellaneous
 ### Use nanoTime
 ```scala
 // Use nanoTime for durations, not currentTimeMillis
 val start = System.nanoTime()
 doWork()
 val elapsed = System.nanoTime() - start
 import java.util.concurrent.TimeUnit
 val elapsedMs = TimeUnit.NANOSECONDS.toMillis(elapsed)
 ```
 ### URI over URL
 ```scala
 // Use URI instead of URL (URL.equals does DNS lookup!)
 val uri = new java.net.URI("http://example.com")
 // Not: val url = new java.net.URL("http://example.com")
 ```
 ## Summary
 1. **Write simple code** - Optimize for readability and maintainability
 2. **Use immutable data** - val, immutable collections, case classes
 3. **Avoid language features** - Limit implicits, avoid symbolic methods
 4. **Type public APIs** - Explicit types for methods and fields
 5. **Prefer explicit over implicit** - Clear is better than concise
 6. **Use standard libraries** - Don't reinvent the wheel
 7. **Follow naming conventions** - PascalCase, camelCase, UPPER_CASE
 8. **Keep methods small** - Rule of 30
 9. **Handle errors explicitly** - Option, Either, exceptions with @throws
 10. **Profile before optimizing** - Measure, don't guess
 For complete details, see the [Databricks Scala Style Guide](https://github.com/databricks/scala-style-guide).
--- a/instructions/vsixtoolkit.instructions.md
+++ b/instructions/vsixtoolkit.instructions.md
@@ -0,0 +1,647 @@
 ---
 description: 'Guidelines for Visual Studio extension (VSIX) development using Community.VisualStudio.Toolkit'
 applyTo: '**/*.cs, **/*.vsct, **/*.xaml, **/source.extension.vsixmanifest'
 ---
 # Visual Studio Extension Development with Community.VisualStudio.Toolkit
 ## Scope
 **These instructions apply ONLY to Visual Studio extensions using `Community.VisualStudio.Toolkit`.**
 Verify the project uses the toolkit by checking for:
 - `Community.VisualStudio.Toolkit.*` NuGet package reference
 - `ToolkitPackage` base class (not raw `AsyncPackage`)
 - `BaseCommand<T>` pattern for commands
 **If the project uses raw VSSDK (`AsyncPackage` directly) or the new `VisualStudio.Extensibility` model, do not apply these instructions.**
 ## Goals
 - Generate async-first, thread-safe extension code
 - Use toolkit abstractions (`VS.*` helpers, `BaseCommand<T>`, `BaseOptionModel<T>`)
 - Ensure all UI respects Visual Studio themes
 - Follow VSSDK and VSTHRD analyzer rules
 - Produce testable, maintainable extension code
 ## Example Prompt Behaviors
 ### ✅ Good Suggestions
 - "Create a command that opens the current file's containing folder using `BaseCommand<T>`"
 - "Add an options page with a boolean setting using `BaseOptionModel<T>`"
 - "Write a tagger provider for C# files that highlights TODO comments"
 - "Show a status bar progress indicator while processing files"
 ### ❌ Avoid
 - Suggesting raw `AsyncPackage` instead of `ToolkitPackage`
 - Using `OleMenuCommandService` directly instead of `BaseCommand<T>`
 - Creating WPF elements without switching to UI thread first
 - Using `.Result`, `.Wait()`, or `Task.Run` for UI work
 - Hardcoding colors instead of using VS theme colors
 ## Project Structure
 ```
 src/
 ├── Commands/           # Command handlers (menu items, toolbar buttons)
 ├── Options/            # Settings/options pages
 ├── Services/           # Business logic and services
 ├── Tagging/            # ITagger implementations (syntax highlighting, outlining)
 ├── Adornments/         # Editor adornments (IntraTextAdornment, margins)
 ├── QuickInfo/          # QuickInfo/tooltip providers
 ├── SuggestedActions/   # Light bulb actions
 ├── Handlers/           # Event handlers (format document, paste, etc.)
 ├── Resources/          # Images, icons, license files
 ├── source.extension.vsixmanifest  # Extension manifest
 ├── VSCommandTable.vsct            # Command definitions (menus, buttons)
 ├── VSCommandTable.cs              # Auto-generated command IDs
 └── *Package.cs                    # Main package class
 ```
 ## Community.VisualStudio.Toolkit Patterns
 ### Global Usings
 Extensions using the toolkit should have these global usings in the Package file:
 ```csharp
 global using System;
 global using Community.VisualStudio.Toolkit;
 global using Microsoft.VisualStudio.Shell;
 global using Task = System.Threading.Tasks.Task;
 ```
 ### Package Class
 ```csharp
 [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
 [InstalledProductRegistration(Vsix.Name, Vsix.Description, Vsix.Version)]
 [ProvideMenuResource("Menus.ctmenu", 1)]
 [Guid(PackageGuids.YourExtensionString)]
 [ProvideOptionPage(typeof(OptionsProvider.GeneralOptions), Vsix.Name, "General", 0, 0, true, SupportsProfiles = true)]
 public sealed class YourPackage : ToolkitPackage
 {
    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
    {
        await this.RegisterCommandsAsync();
    }
 }
 ```
 ### Commands
 Commands use the `[Command]` attribute and inherit from `BaseCommand<T>`:
 ```csharp
 [Command(PackageIds.YourCommandId)]
 internal sealed class YourCommand : BaseCommand<YourCommand>
 {
    protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
    {
        // Command implementation
    }
    // Optional: Control command state (enabled, checked, visible)
    protected override void BeforeQueryStatus(EventArgs e)
    {
        Command.Checked = someCondition;
        Command.Enabled = anotherCondition;
    }
 }
 ```
 ### Options Pages
 ```csharp
 internal partial class OptionsProvider
 {
    [ComVisible(true)]
    public class GeneralOptions : BaseOptionPage<General> { }
 }
 public class General : BaseOptionModel<General>
 {
    [Category("Category Name")]
    [DisplayName("Setting Name")]
    [Description("Description of the setting.")]
    [DefaultValue(true)]
    public bool MySetting { get; set; } = true;
 }
 ```
 ## MEF Components
 ### Tagger Providers
 Use `[Export]` and appropriate `[ContentType]` attributes:
 ```csharp
 [Export(typeof(IViewTaggerProvider))]
 [ContentType("CSharp")]
 [ContentType("Basic")]
 [TagType(typeof(IntraTextAdornmentTag))]
 [TextViewRole(PredefinedTextViewRoles.Document)]
 internal sealed class YourTaggerProvider : IViewTaggerProvider
 {
    [Import]
    internal IOutliningManagerService OutliningManagerService { get; set; }
    public ITagger<T> CreateTagger<T>(ITextView textView, ITextBuffer buffer) where T : ITag
    {
        if (textView == null || !(textView is IWpfTextView wpfTextView))
            return null;
        if (textView.TextBuffer != buffer)
            return null;
        return wpfTextView.Properties.GetOrCreateSingletonProperty(
            () => new YourTagger(wpfTextView)) as ITagger<T>;
    }
 }
 ```
 ### QuickInfo Sources
 ```csharp
 [Export(typeof(IAsyncQuickInfoSourceProvider))]
 [Name("YourQuickInfo")]
 [ContentType("code")]
 [Order(Before = "Default Quick Info Presenter")]
 internal sealed class YourQuickInfoSourceProvider : IAsyncQuickInfoSourceProvider
 {
    public IAsyncQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
    {
        return textBuffer.Properties.GetOrCreateSingletonProperty(
            () => new YourQuickInfoSource(textBuffer));
    }
 }
 ```
 ### Suggested Actions (Light Bulb)
 ```csharp
 [Export(typeof(ISuggestedActionsSourceProvider))]
 [Name("Your Suggested Actions")]
 [ContentType("text")]
 internal sealed class YourSuggestedActionsSourceProvider : ISuggestedActionsSourceProvider
 {
    public ISuggestedActionsSource CreateSuggestedActionsSource(ITextView textView, ITextBuffer textBuffer)
    {
        return new YourSuggestedActionsSource(textView, textBuffer);
    }
 }
 ```
 ## Threading Guidelines
 ### Always switch to UI thread for WPF operations
 ```csharp
 await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 // Now safe to create/modify WPF elements
 ```
 ### Background work
 ```csharp
 ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
 {
    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
    await VS.Commands.ExecuteAsync("View.TaskList");
 });
 ```
 ## VSSDK & Threading Analyzer Rules
 Extensions should enforce these analyzer rules. Add to `.editorconfig`:
 ```ini
 dotnet_diagnostic.VSSDK*.severity = error
 dotnet_diagnostic.VSTHRD*.severity = error
 ```
 ### Performance Rules
 | ID | Rule | Fix |
 |----|------|-----|
 | **VSSDK001** | Derive from `AsyncPackage` | Use `ToolkitPackage` (derives from AsyncPackage) |
 | **VSSDK002** | `AllowsBackgroundLoading = true` | Add to `[PackageRegistration]` |
 ### Threading Rules (VSTHRD)
 | ID | Rule | Fix |
 |----|------|-----|
 | **VSTHRD001** | Avoid `.Wait()` | Use `await` |
 | **VSTHRD002** | Avoid `JoinableTaskFactory.Run` | Use `RunAsync` or `await` |
 | **VSTHRD010** | COM calls require UI thread | `await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync()` |
 | **VSTHRD100** | No `async void` | Use `async Task` |
 | **VSTHRD110** | Observe async results | `await task;` or suppress with pragma |
 ## Visual Studio Theming
 **All UI must respect VS themes (Light, Dark, Blue, High Contrast)**
 ### WPF Theming with Environment Colors
 ```xml
 <!-- MyControl.xaml -->
 <UserControl x:Class="MyExt.MyControl"
             xmlns:vsui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0">
    <Grid Background="{DynamicResource {x:Static vsui:EnvironmentColors.ToolWindowBackgroundBrushKey}}">
        <TextBlock Foreground="{DynamicResource {x:Static vsui:EnvironmentColors.ToolWindowTextBrushKey}}"
                   Text="Hello, themed world!" />
    </Grid>
 </UserControl>
 ```
 ### Toolkit Auto-Theming (Recommended)
 The toolkit provides automatic theming for WPF UserControls:
 ```xml
 <UserControl x:Class="MyExt.MyUserControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:toolkit="clr-namespace:Community.VisualStudio.Toolkit;assembly=Community.VisualStudio.Toolkit"
             toolkit:Themes.UseVsTheme="True">
    <!-- Controls automatically get VS styling -->
 </UserControl>
 ```
 For dialog windows, use `DialogWindow`:
 ```xml
 <platform:DialogWindow
    x:Class="MyExt.MyDialog"
    xmlns:platform="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0"
    xmlns:toolkit="clr-namespace:Community.VisualStudio.Toolkit;assembly=Community.VisualStudio.Toolkit"
    toolkit:Themes.UseVsTheme="True">
 </platform:DialogWindow>
 ```
 ### Common Theme Color Tokens
 | Category | Token | Usage |
 |----------|-------|-------|
 | **Background** | `EnvironmentColors.ToolWindowBackgroundBrushKey` | Window/panel background |
 | **Foreground** | `EnvironmentColors.ToolWindowTextBrushKey` | Text |
 | **Command Bar** | `EnvironmentColors.CommandBarTextActiveBrushKey` | Menu items |
 | **Links** | `EnvironmentColors.ControlLinkTextBrushKey` | Hyperlinks |
 ### Theme-Aware Icons
 Use `KnownMonikers` from the VS Image Catalog for theme-aware icons:
 ```csharp
 public ImageMoniker IconMoniker => KnownMonikers.Settings;
 ```
 In VSCT:
 ```xml
 <Icon guid="ImageCatalogGuid" id="Settings"/>
 <CommandFlag>IconIsMoniker</CommandFlag>
 ```
 ## Common VS SDK APIs
 ### VS Helper Methods (Community.VisualStudio.Toolkit)
 ```csharp
 // Status bar
 await VS.StatusBar.ShowMessageAsync("Message");
 await VS.StatusBar.ShowProgressAsync("Working...", currentStep, totalSteps);
 // Solution/Projects
 Solution solution = await VS.Solutions.GetCurrentSolutionAsync();
 IEnumerable<SolutionItem> items = await VS.Solutions.GetActiveItemsAsync();
 bool isOpen = await VS.Solutions.IsOpenAsync();
 // Documents
 DocumentView docView = await VS.Documents.GetActiveDocumentViewAsync();
 string text = docView?.TextBuffer?.CurrentSnapshot.GetText();
 await VS.Documents.OpenAsync(fileName);
 await VS.Documents.OpenInPreviewTabAsync(fileName);
 // Commands
 await VS.Commands.ExecuteAsync("View.TaskList");
 // Settings
 await VS.Settings.OpenAsync<OptionsProvider.GeneralOptions>();
 // Messages
 await VS.MessageBox.ShowAsync("Title", "Message");
 await VS.MessageBox.ShowErrorAsync("Extension Name", ex.ToString());
 // Events
 VS.Events.SolutionEvents.OnAfterOpenProject += OnAfterOpenProject;
 VS.Events.DocumentEvents.Saved += OnDocumentSaved;
 ```
 ### Working with Settings
 ```csharp
 // Read settings synchronously
 var value = General.Instance.MyOption;
 // Read settings asynchronously
 var general = await General.GetLiveInstanceAsync();
 var value = general.MyOption;
 // Write settings
 General.Instance.MyOption = newValue;
 General.Instance.Save();
 // Or async
 general.MyOption = newValue;
 await general.SaveAsync();
 // Listen for settings changes
 General.Saved += OnSettingsSaved;
 ```
 ### Text Buffer Operations
 ```csharp
 // Get snapshot
 ITextSnapshot snapshot = textBuffer.CurrentSnapshot;
 // Get line
 ITextSnapshotLine line = snapshot.GetLineFromLineNumber(lineNumber);
 string lineText = line.GetText();
 // Create tracking span
 ITrackingSpan trackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive);
 // Edit buffer
 using (ITextEdit edit = textBuffer.CreateEdit())
 {
    edit.Replace(span, newText);
    edit.Apply();
 }
 // Insert at caret position
 DocumentView docView = await VS.Documents.GetActiveDocumentViewAsync();
 if (docView?.TextView != null)
 {
    SnapshotPoint position = docView.TextView.Caret.Position.BufferPosition;
    docView.TextBuffer?.Insert(position, "text to insert");
 }
 ```
 ## VSCT Command Table
 ### Menu/Command Structure
 ```xml
 <Commands package="YourPackage">
  <Menus>
    <Menu guid="YourPackage" id="SubMenu" type="Menu">
      <Parent guid="YourPackage" id="MenuGroup"/>
      <Strings>
        <ButtonText>Menu Name</ButtonText>
        <CommandName>Menu Name</CommandName>
        <CanonicalName>.YourExtension.MenuName</CanonicalName>
      </Strings>
    </Menu>
  </Menus>
  <Groups>
    <Group guid="YourPackage" id="MenuGroup" priority="0x0600">
      <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_CODEWIN"/>
    </Group>
  </Groups>
  <Buttons>
    <Button guid="YourPackage" id="CommandId" type="Button">
      <Parent guid="YourPackage" id="MenuGroup"/>
      <Icon guid="ImageCatalogGuid" id="Settings"/>
      <CommandFlag>IconIsMoniker</CommandFlag>
      <CommandFlag>DynamicVisibility</CommandFlag>
      <Strings>
        <ButtonText>Command Name</ButtonText>
        <CanonicalName>.YourExtension.CommandName</CanonicalName>
      </Strings>
    </Button>
  </Buttons>
 </Commands>
 <Symbols>
  <GuidSymbol name="YourPackage" value="{guid-here}">
    <IDSymbol name="MenuGroup" value="0x0001"/>
    <IDSymbol name="CommandId" value="0x0100"/>
  </GuidSymbol>
 </Symbols>
 ```
 ## Best Practices
 ### 1. Performance
 - Check file/buffer size before processing large documents
 - Use `NormalizedSnapshotSpanCollection` for efficient span operations
 - Cache parsed results when possible
 - Use `ConfigureAwait(false)` in library code
 ```csharp
 // Skip large files
 if (buffer.CurrentSnapshot.Length > 150000)
    return null;
 ```
 ### 2. Error Handling
 - Wrap external operations in try-catch
 - Log errors appropriately
 - Never let exceptions crash VS
 ```csharp
 try
 {
    // Operation
 }
 catch (Exception ex)
 {
    await ex.LogAsync();
 }
 ```
 ### 3. Disposable Resources
 - Implement `IDisposable` on taggers and other long-lived objects
 - Unsubscribe from events in Dispose
 ```csharp
 public void Dispose()
 {
    if (!_isDisposed)
    {
        _buffer.Changed -= OnBufferChanged;
        _isDisposed = true;
    }
 }
 ```
 ### 4. Content Types
 Common content types for `[ContentType]` attribute:
 - `"text"` - All text files
 - `"code"` - All code files
 - `"CSharp"` - C# files
 - `"Basic"` - VB.NET files
 - `"CSS"`, `"LESS"`, `"SCSS"` - Style files
 - `"TypeScript"`, `"JavaScript"` - Script files
 - `"HTML"`, `"HTMLX"` - HTML files
 - `"XML"` - XML files
 - `"JSON"` - JSON files
 ### 5. Images and Icons
 Use `KnownMonikers` from the VS Image Catalog:
 ```csharp
 public ImageMoniker IconMoniker => KnownMonikers.Settings;
 ```
 In VSCT:
 ```xml
 <Icon guid="ImageCatalogGuid" id="Settings"/>
 <CommandFlag>IconIsMoniker</CommandFlag>
 ```
 ## Testing
 - Use `[VsTestMethod]` for tests requiring VS context
 - Mock VS services when possible
 - Test business logic separately from VS integration
 ## Common Pitfalls
 | Pitfall | Solution |
 |---------|----------|
 | Blocking UI thread | Always use `async`/`await` |
 | Creating WPF on background thread | Call `SwitchToMainThreadAsync()` first |
 | Ignoring cancellation tokens | Pass them through async chains |
 | VSCommandTable.cs mismatch | Regenerate after VSCT changes |
 | Hardcoded GUIDs | Use `PackageGuids` and `PackageIds` constants |
 | Swallowing exceptions | Log with `await ex.LogAsync()` |
 | Missing DynamicVisibility | Required for `BeforeQueryStatus` to work |
 | Using `.Result`, `.Wait()` | Causes deadlocks; always `await` |
 | Hardcoded colors | Use VS theme colors (`EnvironmentColors`) |
 | `async void` methods | Use `async Task` instead |
 ## Validation
 Build and verify the extension:
 ```bash
 msbuild /t:rebuild
 ```
 Ensure analyzers are enabled in `.editorconfig`:
 ```ini
 dotnet_diagnostic.VSSDK*.severity = error
 dotnet_diagnostic.VSTHRD*.severity = error
 ```
 Test in VS Experimental Instance before release.
 ## NuGet Packages
 | Package | Purpose |
 |---------|---------|
 | `Community.VisualStudio.Toolkit.17` | Simplifies VS extension development |
 | `Microsoft.VisualStudio.SDK` | Core VS SDK |
 | `Microsoft.VSSDK.BuildTools` | Build tools for VSIX |
 | `Microsoft.VisualStudio.Threading.Analyzers` | Threading analyzers |
 | `Microsoft.VisualStudio.SDK.Analyzers` | VSSDK analyzers |
 ## Resources
 - [Community.VisualStudio.Toolkit](https://github.com/VsixCommunity/Community.VisualStudio.Toolkit)
 - [VS Extensibility Docs](https://learn.microsoft.com/en-us/visualstudio/extensibility/)
 - [VSIX Community Samples](https://github.com/VsixCommunity/Samples)
 ## README and Marketplace Presentation
 A good README works on both GitHub and the VS Marketplace. The Marketplace uses the README.md as the extension's description page.
 ### README Structure
 ```markdown
 [marketplace]: https://marketplace.visualstudio.com/items?itemName=Publisher.ExtensionName
 [repo]: https://github.com/user/repo
 # Extension Name
 [![Build](https://github.com/user/repo/actions/workflows/build.yaml/badge.svg)](...)
 [![Visual Studio Marketplace Version](https://img.shields.io/visual-studio-marketplace/v/Publisher.ExtensionName)][marketplace]
 [![Visual Studio Marketplace Downloads](https://img.shields.io/visual-studio-marketplace/d/Publisher.ExtensionName)][marketplace]
 Download this extension from the [Visual Studio Marketplace][marketplace]
 or get the [CI build](http://vsixgallery.com/extension/ExtensionId/).
 --------------------------------------
 **Hook line that sells the extension in one sentence.**
 ![Screenshot](art/screenshot.png)
 ## Features
 ### Feature 1
 Description with screenshot...
 ## How to Use
 ...
 ## License
 [Apache 2.0](LICENSE)
 ```
 ### README Best Practices
 | Element | Guideline |
 |---------|-----------|
 | **Title** | Use the same name as `DisplayName` in vsixmanifest |
 | **Hook line** | Bold, one-sentence value proposition immediately after badges |
 | **Screenshots** | Place in `/art` folder, use relative paths (`art/image.png`) |
 | **Image sizes** | Keep under 1MB, 800-1200px wide for clarity |
 | **Badges** | Version, downloads, rating, build status |
 | **Feature sections** | Use H3 (`###`) with screenshots for each major feature |
 | **Keyboard shortcuts** | Format as **Ctrl+M, Ctrl+C** (bold) |
 | **Tables** | Great for comparing options or listing features |
 | **Links** | Use reference-style links at top for cleaner markdown |
 ### VSIX Manifest (source.extension.vsixmanifest)
 ```xml
 <Metadata>
  <Identity Id="ExtensionName.guid-here" Version="1.0.0" Language="en-US" Publisher="Your Name" />
  <DisplayName>Extension Name</DisplayName>
  <Description xml:space="preserve">Short, compelling description under 200 chars. This appears in search results and the extension tile.</Description>
  <MoreInfo>https://github.com/user/repo</MoreInfo>
  <License>Resources\LICENSE.txt</License>
  <Icon>Resources\Icon.png</Icon>
  <PreviewImage>Resources\Preview.png</PreviewImage>
  <Tags>keyword1, keyword2, keyword3</Tags>
 </Metadata>
 ```
 ### Manifest Best Practices
 | Element | Guideline |
 |---------|-----------|
 | **DisplayName** | 3-5 words, no "for Visual Studio" (implied) |
 | **Description** | Under 200 chars, focus on value not features. Appears in search tiles |
 | **Tags** | 5-10 relevant keywords, comma-separated, helps discoverability |
 | **Icon** | 128x128 or 256x256 PNG, simple design visible at small sizes |
 | **PreviewImage** | 200x200 PNG, can be same as Icon or a feature screenshot |
 | **MoreInfo** | Link to GitHub repo for documentation and issues |
 ### Writing Tips
 1. **Lead with benefits, not features** - "Stop wrestling with XML comments" beats "XML comment formatter"
 2. **Show, don't tell** - Screenshots are more convincing than descriptions
 3. **Use consistent terminology** - Match terms between README, manifest, and UI
 4. **Keep the description scannable** - Short paragraphs, bullet points, tables
 5. **Include keyboard shortcuts** - Users love productivity tips
 6. **Add a "Why" section** - Explain the problem before the solution