scc-universal 1.1.0

package/skills/sf-approval-processes/SKILL.md

@@ -0,0 +1,315 @@
+---
+name: sf-approval-processes
+description: >-
+  Use when designing Salesforce Apex approval processes, multi-step approvals,
+  or Flow-integrated submissions. Do NOT use for general Apex or Flow-only work.
+origin: SCC
+user-invocable: false
+---
+
+# Salesforce Approval Processes
+
+@../_reference/APPROVAL_PROCESSES.md
+
+## When to Use
+
+- Designing multi-step approval workflows (discounts, expenses, contracts)
+- Building Apex-driven approval submissions or programmatic approvals/rejections
+- Integrating approval logic with Flows (Spring '26 Integrated Approval Screen component)
+- Troubleshooting approval routing, locked records, or missing approval history
+- Migrating from email-based approvals to in-app approval workflows
+
+---
+
+## Approval Process Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 Approval Process                     │
+├─────────────────────────────────────────────────────┤
+│  Entry Criteria     │ WHO can submit? WHEN?          │
+│  Initial Submitter  │ Record owner, specific users   │
+├─────────────────────────────────────────────────────┤
+│  Step 1: Manager    │ Approver: Manager field         │
+│  Step 2: VP         │ Approver: Related user field    │
+│  Step 3: Finance    │ Approver: Queue                 │
+├─────────────────────────────────────────────────────┤
+│  Initial Actions    │ Lock record, set Status         │
+│  Approval Actions   │ Unlock, update field, email     │
+│  Rejection Actions  │ Unlock, set Status to Rejected  │
+│  Recall Actions     │ Unlock, clear approval fields   │
+└─────────────────────────────────────────────────────┘
+```
+
+### Entry Criteria
+
+```
+Amount__c > 10000 AND Status__c = 'Draft'
+RecordType.Name = 'Enterprise' AND Discount__c > 20
+
+Formula:
+AND(Amount__c > 10000, ISPICKVAL(Status__c, 'Draft'), NOT(ISBLANK(OwnerId)))
+```
+
+### Approval Steps
+
+| Property | Options |
+|---|---|
+| Approver | User field, Manager field, Queue, Related user |
+| Criteria | All records OR filter criteria (step-specific) |
+| Reject behavior | Final rejection OR go to previous step |
+| Unanimity | All must approve OR first response |
+
+### Parallel Approvals
+
+- **Unanimous**: All assigned approvers must approve
+- **First Response**: First approver's decision applies
+- For true parallel independent steps (Legal AND Finance simultaneously), use multiple processes or custom Apex
+
+---
+
+## Approval Actions
+
+### Initial Submission Actions
+
+- Field Update: `Status__c = "Pending Approval"`
+- Email Alert: Notify approver(s)
+- Record Lock: Prevent edits during approval
+- Outbound Message: Notify external system
+
+### Final Approval Actions
+
+- Field Update: `Status__c = "Approved"`
+- Email Alert: Notify submitter
+- Record Unlock: Allow edits again
+
+### Final Rejection Actions
+
+- Field Update: `Status__c = "Rejected"`
+- Email Alert: Notify submitter with rejection reason
+- Record Unlock
+
+---
+
+## Apex Approval Processing
+
+### Submitting a Record for Approval
+
+```apex
+public class ApprovalService {
+    public static void submitForApproval(Id recordId, String comments) {
+        Approval.ProcessSubmitRequest request = new Approval.ProcessSubmitRequest();
+        request.setObjectId(recordId);
+        request.setSubmitterId(UserInfo.getUserId());
+        request.setComments(comments);
+
+        Approval.ProcessResult result = Approval.process(request);
+        if (result.isSuccess()) {
+            System.debug('Submitted. Instance ID: ' + result.getInstanceId());
+        } else {
+            for (Database.Error err : result.getErrors()) {
+                System.debug(LoggingLevel.ERROR, 'Failed: ' + err.getMessage());
+            }
+        }
+    }
+}
+```
+
+### Approving or Rejecting Programmatically
+
+```apex
+public static void approveRecord(Id workItemId, String comments) {
+    Approval.ProcessWorkitemRequest request = new Approval.ProcessWorkitemRequest();
+    request.setWorkitemId(workItemId);
+    request.setAction('Approve');
+    request.setComments(comments);
+
+    Approval.ProcessResult result = Approval.process(request);
+    if (!result.isSuccess()) {
+        throw new ApprovalException('Approval failed: ' + result.getErrors());
+    }
+}
+
+public static void rejectRecord(Id workItemId, String comments) {
+    Approval.ProcessWorkitemRequest request = new Approval.ProcessWorkitemRequest();
+    request.setWorkitemId(workItemId);
+    request.setAction('Reject');
+    request.setComments(comments);
+
+    Approval.ProcessResult result = Approval.process(request);
+    if (!result.isSuccess()) {
+        throw new ApprovalException('Rejection failed: ' + result.getErrors());
+    }
+}
+```
+
+### Querying Approval Status
+
+```apex
+// Pending work items for current user
+List<ProcessInstanceWorkitem> pendingItems = [
+    SELECT Id, ProcessInstance.TargetObjectId, ProcessInstance.Status,
+           ProcessInstance.TargetObject.Name, CreatedDate
+    FROM ProcessInstanceWorkitem
+    WHERE ActorId = :UserInfo.getUserId()
+    ORDER BY CreatedDate DESC
+];
+
+// Approval history for a record
+List<ProcessInstanceStep> history = [
+    SELECT StepStatus, Comments, Actor.Name, CreatedDate
+    FROM ProcessInstanceStep
+    WHERE ProcessInstance.TargetObjectId = :recordId
+    ORDER BY CreatedDate ASC
+];
+
+// Active work item for a specific record
+ProcessInstanceWorkitem workItem = [
+    SELECT Id FROM ProcessInstanceWorkitem
+    WHERE ProcessInstance.TargetObjectId = :recordId
+      AND ProcessInstance.Status = 'Pending'
+    LIMIT 1
+];
+```
+
+---
+
+## Flow Integration
+
+### Submitting for Approval from Flow
+
+Use the **Submit for Approval** action element: specify the record ID, optionally the approval process name, submitter, and comments.
+
+### Spring '26 — Integrated Approval Screen Component
+
+Screen Flows can include an Integrated Approval component for in-flow approve/reject:
+
+```
+Screen Flow:
+  1. Show Record Details
+  2. Integrated Approval Component (history, Approve/Reject buttons, comments)
+  3. Decision: Check outcome
+  4. Update Records based on outcome
+```
+
+### Dynamic Approvers via Flow
+
+```
+Autolaunched Flow (invoked by Approval Process):
+  1. Get Records: record's Region__c and Amount__c
+  2. Decision: Route by amount and region
+     - > 500K → VP Finance
+     - > 100K → Regional Manager
+     - Otherwise → Direct Manager
+  3. Return approver User ID
+```
+
+---
+
+## Design Patterns
+
+### Delegation and Backup Approvers
+
+- Configure Delegated Approvers in user settings for vacation coverage
+- Use Queues as approvers so any queue member can approve
+- Set approval step timeout for auto-escalation
+
+### Approval History Tracking
+
+```apex
+public static List<Map<String, Object>> getApprovalHistory(Id recordId) {
+    List<Map<String, Object>> trail = new List<Map<String, Object>>();
+    for (ProcessInstance pi : [
+        SELECT Id, Status, CreatedDate,
+            (SELECT StepStatus, Comments, Actor.Name, CreatedDate
+             FROM StepsAndWorkitems ORDER BY CreatedDate)
+        FROM ProcessInstance
+        WHERE TargetObjectId = :recordId
+        ORDER BY CreatedDate DESC
+    ]) {
+        for (ProcessInstanceHistory step : pi.StepsAndWorkitems) {
+            trail.add(new Map<String, Object>{
+                'status' => step.StepStatus,
+                'approver' => step.Actor.Name,
+                'comments' => step.Comments,
+                'date' => step.CreatedDate
+            });
+        }
+    }
+    return trail;
+}
+```
+
+---
+
+## Testing Approval Processes
+
+These tests require an approval process to be deployed in the org's metadata. Approval processes cannot be created programmatically in tests.
+
+```apex
+@isTest
+static void testApprovalSubmission() {
+    Account testAccount = new Account(Name = 'Test Account', AnnualRevenue = 50000);
+    insert testAccount;
+
+    Test.startTest();
+    Approval.ProcessSubmitRequest request = new Approval.ProcessSubmitRequest();
+    request.setObjectId(testAccount.Id);
+    request.setSubmitterId(UserInfo.getUserId());
+    Approval.ProcessResult result = Approval.process(request);
+    Test.stopTest();
+
+    System.assert(result.isSuccess(), 'Approval submission should succeed');
+    System.assertEquals('Pending', result.getInstanceStatus());
+}
+
+@isTest
+static void testApprovalProcess() {
+    Account testAccount = new Account(Name = 'Test', AnnualRevenue = 50000);
+    insert testAccount;
+
+    Approval.ProcessSubmitRequest submitReq = new Approval.ProcessSubmitRequest();
+    submitReq.setObjectId(testAccount.Id);
+    Approval.ProcessResult submitResult = Approval.process(submitReq);
+
+    Id workItemId = submitResult.getNewWorkitemIds()[0];
+
+    Approval.ProcessWorkitemRequest approveReq = new Approval.ProcessWorkitemRequest();
+    approveReq.setWorkitemId(workItemId);
+    approveReq.setAction('Approve');
+    approveReq.setComments('Looks good');
+
+    Test.startTest();
+    Approval.ProcessResult approveResult = Approval.process(approveReq);
+    Test.stopTest();
+
+    System.assert(approveResult.isSuccess());
+    System.assertEquals('Approved', approveResult.getInstanceStatus());
+}
+```
+
+---
+
+## Metadata Deployment
+
+```
+approvalProcesses/
+  Discount_Approval.approvalProcess-meta.xml
+```
+
+Include in `package.xml`:
+
+```xml
+<types>
+    <members>Opportunity.Discount_Approval</members>
+    <name>ApprovalProcess</name>
+</types>
+```
+
+Approval processes reference users, queues, and email templates. Ensure dependencies exist in the target org before deployment.
+
+---
+
+## Related
+
+- **Constraints**: `sf-apex-constraints` — Governor limits and Apex safety rules

package/skills/sf-aura-development/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: sf-aura-development
+description: >-
+  Salesforce Aura component development — bundles, events, server-side actions,
+  Locker Service, and LWC migration. Use when maintaining or migrating Aura.
+origin: SCC
+user-invocable: false
+---
+
+# Aura Component Development
+
+Aura is Salesforce's original Lightning component framework (introduced 2014). While LWC is the modern standard, thousands of production orgs still run Aura components. This skill covers authoring, maintaining, and migrating Aura components.
+
+**Note:** Aura is in maintenance mode. For new development, use LWC (see sf-lwc-development).
+
+## When to Use
+
+- When maintaining or extending existing Aura components that cannot be rewritten immediately
+- When migrating Aura components to LWC and needing to understand the source patterns
+- When building interoperability layers between LWC and Aura
+- When debugging Aura event propagation, server-side action callbacks, or Locker Service errors
+- When working with features that still require Aura wrappers (Lightning Out, legacy AppExchange)
+
+@../_reference/AURA_COMPONENTS.md
+
+---
+
+## Component Creation Procedure
+
+An Aura component is a folder (bundle) containing up to eight files. Only the `.cmp` file is required.
+
+```
+force-app/main/default/aura/AccountManager/
+    AccountManager.cmp           <- Component markup (required)
+    AccountManagerController.js  <- Client-side controller (action handlers)
+    AccountManagerHelper.js      <- Reusable logic (called by controller)
+    AccountManagerRenderer.js    <- Custom rendering overrides (rare)
+    AccountManager.css           <- Component-scoped styles
+    AccountManager.design        <- App Builder property editor config
+    AccountManager.cmp-meta.xml  <- Metadata (apiVersion, description)
+```
+
+### Component Markup (.cmp)
+
+```xml
+<aura:component controller="AccountController"
+                implements="force:appHostable,flexipage:availableForAllPageTypes"
+                access="global">
+    <aura:attribute name="accounts" type="Account[]" default="[]" />
+    <aura:attribute name="isLoading" type="Boolean" default="true" />
+    <aura:attribute name="errorMessage" type="String" />
+
+    <aura:registerEvent name="accountSelected" type="c:AccountSelectedEvent" />
+    <aura:handler name="init" value="{!this}" action="{!c.doInit}" />
+
+    <lightning:card title="Account Manager" iconName="standard:account">
+        <aura:if isTrue="{!v.isLoading}">
+            <lightning:spinner alternativeText="Loading" size="small" />
+            <aura:set attribute="else">
+                <aura:iteration items="{!v.accounts}" var="acct">
+                    <lightning:tile label="{!acct.Name}">
+                        <dl class="slds-list_horizontal slds-wrap">
+                            <dt class="slds-item_label">Type:</dt>
+                            <dd class="slds-item_detail">{!acct.Type}</dd>
+                        </dl>
+                    </lightning:tile>
+                </aura:iteration>
+            </aura:set>
+        </aura:if>
+    </lightning:card>
+</aura:component>
+```
+
+---
+
+## Event Handling
+
+### Component Events (Parent-Child)
+
+```xml
+<!-- AccountSelectedEvent.evt -->
+<aura:event type="COMPONENT" description="Fired when an account is selected">
+    <aura:attribute name="accountId" type="String" />
+</aura:event>
+```
+
+```javascript
+// Child controller — firing
+handleAccountClick: function(component, event, helper) {
+    var compEvent = component.getEvent("accountSelected");
+    compEvent.setParams({ accountId: event.currentTarget.dataset.accountId });
+    compEvent.fire();
+}
+```
+
+```xml
+<!-- Parent — handling -->
+<c:AccountTile onaccountSelected="{!c.handleAccountSelected}" />
+```
+
+### Application Events (Cross-Component)
+
+```xml
+<aura:event type="APPLICATION" description="Broadcast notification">
+    <aura:attribute name="message" type="String" />
+</aura:event>
+```
+
+```javascript
+// Firing
+var appEvent = $A.get("e.c:GlobalNotificationEvent");
+appEvent.setParams({ message: "Record saved" });
+appEvent.fire();
+```
+
+```xml
+<!-- Any component can handle -->
+<aura:handler event="c:GlobalNotificationEvent" action="{!c.handleNotification}" />
+```
+
+Prefer component events over application events. For new cross-component communication, use Lightning Message Service instead.
+
+---
+
+## Controller and Helper Patterns
+
+Keep controllers thin; helpers do the work.
+
+```javascript
+// AccountManagerController.js
+({
+    doInit: function(component, event, helper) {
+        helper.loadAccounts(component);
+    },
+    handleSearch: function(component, event, helper) {
+        helper.loadAccounts(component);
+    }
+})
+```
+
+```javascript
+// AccountManagerHelper.js
+({
+    loadAccounts: function(component) {
+        component.set("v.isLoading", true);
+        var action = component.get("c.getAccounts");
+        action.setParams({
+            searchTerm: component.get("v.searchTerm") || ""
+        });
+        action.setCallback(this, function(response) {
+            var state = response.getState();
+            if (state === "SUCCESS") {
+                component.set("v.accounts", response.getReturnValue());
+            } else if (state === "ERROR") {
+                this.handleErrors(component, response.getError());
+            } else if (state === "INCOMPLETE") {
+                component.set("v.errorMessage", "Server unreachable.");
+            }
+            component.set("v.isLoading", false);
+        });
+        $A.enqueueAction(action);
+    },
+
+    handleErrors: function(component, errors) {
+        var message = "Unknown error";
+        if (errors && errors[0] && errors[0].message) {
+            message = errors[0].message;
+        }
+        component.set("v.errorMessage", message);
+    }
+})
+```
+
+---
+
+## Server-Side Communication
+
+### $A.enqueueAction() Pattern
+
+All Apex calls in Aura go through the action queue. Handle all three states: SUCCESS, ERROR, INCOMPLETE.
+
+### Storable Actions (Client-Side Caching)
+
+```javascript
+var action = component.get("c.getPicklistValues");
+action.setStorable(); // Only for @AuraEnabled(cacheable=true) methods
+```
+
+Callback may fire twice: once from cache, once from server. Do not use for DML operations.
+
+### $A.getCallback() for Async Code
+
+Any code executing outside the Aura lifecycle (setTimeout, Promises, third-party callbacks) must use `$A.getCallback()`:
+
+```javascript
+setTimeout($A.getCallback(function() {
+    if (component.isValid()) {
+        component.set("v.status", "Complete");
+    }
+}), 2000);
+```
+
+---
+
+## Interoperability with LWC
+
+### Embedding LWC Inside Aura
+
+```xml
+<!-- AuraWrapper.cmp -->
+<aura:component>
+    <c:lwcRecordDetail
+        record-id="{!v.selectedRecordId}"
+        onrecordupdate="{!c.handleRecordUpdate}" />
+</aura:component>
+```
+
+**Aura to LWC** — pass data via attributes mapped to `@api` properties.
+**LWC to Aura** — dispatch `CustomEvent`; Aura receives via `on{eventname}` handler, access detail via `event.getParam("detail")`.
+
+---
+
+## Migration to LWC
+
+### Strategy
+
+1. **Inventory** — list all Aura components, dependencies, usage locations
+2. **Prioritize** — start with leaf components (no child Aura dependencies)
+3. **Wrap** — replace Aura parents with LWC, keeping Aura children via interop
+4. **Convert** — rewrite using LWC patterns
+5. **Test** — validate behavior parity
+6. **Deploy** — replace references on pages/apps
+
+### Key Mappings
+
+| Aura | LWC |
+|------|-----|
+| `aura:handler name="init"` | `connectedCallback()` |
+| `aura:handler name="destroy"` | `disconnectedCallback()` |
+| `aura:attribute` | `@api` properties |
+| `aura:if` / `aura:set` | `lwc:if` / `lwc:elseif` / `lwc:else` |
+| `aura:iteration` | `for:each` with `key` |
+| `$A.enqueueAction()` | `@wire` or imperative `await` |
+| `component.get("v.attr")` | `this.propertyName` |
+| `component.set("v.attr", val)` | `this.propertyName = val` |
+| `component.find("auraId")` | `this.template.querySelector()` |
+| Component events | `CustomEvent` |
+| Application events | Lightning Message Service |
+| `$A.getCallback()` | Not needed (LWC handles async natively) |
+| Helper.js (separate file) | Class methods (single JS file) |
+| `$A.createComponent()` | `lwc:component` with `lwc:is` |
+
+---
+
+## Related
+
+### Guardrails
+
+- **sf-lwc-constraints** — Enforced rules for LWC (relevant for interop and migration targets)
+
+### Agents
+
+- **sf-aura-reviewer** — For interactive, in-depth Aura review guidance

package/skills/sf-build-fix/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: sf-build-fix
+description: "Auto-fix Salesforce build errors — Apex compilation, metadata conflicts, dependencies, test failures. Use when build errors block deployment. Do NOT use for writing new features or refactoring."
+origin: SCC
+user-invocable: false
+disable-model-invocation: true
+---
+
+# Build Fix — Salesforce Build and Deployment Error Resolution
+
+Fix build and deployment errors incrementally. Parse error output, classify issues, fix one at a time, re-validate.
+
+Reference: @../_reference/DEPLOYMENT_CHECKLIST.md
+
+## When to Use
+
+- When Apex compilation errors are blocking a deployment
+- When metadata conflicts prevent deploying to a target org
+- When test failures need to be resolved before deployment validation passes
+- When dependency resolution is needed (missing objects, fields, or class references)
+- When you receive build errors from `sf project deploy` and need systematic resolution
+
+## Workflow
+
+### Step 1 — Capture Errors
+
+Run a dry-run deployment or check compiler output:
+
+```bash
+sf project deploy validate --target-org <alias> --json 2>&1
+```
+
+If the user pasted error output directly, use that instead.
+
+### Step 2 — Parse and Classify
+
+Group errors by type and fix in this dependency order:
+
+| Priority | Error Type | Fix Strategy |
+|----------|-----------|--------------|
+| 1 | Missing object/field metadata | Deploy metadata first -- objects before classes |
+| 2 | Missing class/interface reference | Check spelling, verify class exists, check API version |
+| 3 | Type mismatch | Cast explicitly, check null handling, verify generic types |
+| 4 | Method signature changed | Update all callers, check for overloaded methods |
+| 5 | Metadata conflict | Retrieve latest from org with `sf project retrieve start`, merge |
+| 6 | Test failure | Fix test data setup, update assertions, check @TestSetup |
+| 7 | Governor limit in test | Add Test.startTest()/stopTest(), reduce data volume |
+
+### Step 3 — Fix One at a Time
+
+For each error:
+
+1. Read the file at the reported line number
+2. Understand the context (class, method, trigger)
+3. Apply the minimal fix
+4. Verify it compiles: `sf project deploy validate --metadata "ApexClass:<ClassName>" --target-org <org>`
+
+### Step 4 — Re-validate
+
+After all fixes:
+
+```bash
+sf project deploy validate --target-org <alias> --test-level RunLocalTests
+```
+
+## Common Apex Compilation Errors
+
+| Error Message Pattern | Root Cause | Fix |
+|----------------------|------------|-----|
+| `Variable does not exist: X` | Undeclared variable or field removed | Declare variable or check field API name |
+| `Method does not exist or incorrect signature` | Wrong parameter types or method renamed | Check method signature in target class |
+| `Illegal assignment from X to Y` | Type mismatch | Add explicit cast or fix generic type |
+| `Non-void method might not return a value` | Missing return in a branch | Add return statement to all code paths |
+| `Compile Error: unexpected token` | Syntax error | Check line above the reported line |
+| `System.NullPointerException` (test) | Null reference in test setup | Add null checks or fix @TestSetup |
+| `Duplicate value found` (test) | Test data collision | Use unique identifiers, avoid SeeAllData |
+| `FIELD_CUSTOM_VALIDATION_EXCEPTION` (test) | Validation rule blocking test DML | Populate all required fields in test data |
+| `MIXED_DML_OPERATION` (test) | Setup + non-setup DML in same transaction | Use `System.runAs()` in tests or `@future` in production |
+| `UNABLE_TO_LOCK_ROW` (test) | Concurrent test data conflicts | Use unique records per test method |
+
+## Dependency Resolution Order
+
+When deploying multiple metadata types, follow this order:
+
+1. Custom Objects and Fields
+2. Record Types and Page Layouts
+3. Apex Classes (utilities and base classes first)
+4. Apex Triggers
+5. Lightning Web Components
+6. Flows (Process Builder is deprecated since Winter '23 -- migrate to Flows)
+7. Permission Sets and Profiles
+8. Apex Test Classes (verify at end)
+
+## Metadata Conflict Resolution
+
+When `sf project deploy` reports conflicts:
+
+1. **Retrieve current org state**: `sf project retrieve start --metadata <type>:<name>`
+2. **Compare**: `diff force-app/main/default/<path> <retrieved-path>`
+3. **Merge**: Keep production changes, layer your modifications on top
+4. **Do not force-overwrite** production metadata without understanding the diff
+
+## Rules
+
+- Fix one error at a time -- cascade fixes often resolve multiple issues
+- Do NOT refactor while fixing builds
+- Do NOT change architecture
+- If a fix introduces new errors, revert and try a different approach
+
+## Examples
+
+```
+sf-build-fix
+sf-build-fix Fix the Apex compile errors from this deployment output: <paste errors>
+sf-build-fix The AccountService.cls has a type mismatch on line 47
+sf-build-fix Resolve the metadata conflicts blocking our deployment to UAT
+```
+
+## Related
+
+- **Constraints**: `sf-deployment-constraints` -- deployment safety rules and validation gates