scc-universal 1.1.0

package/.cursor/skills/sf-tdd-workflow/SKILL.md

@@ -0,0 +1,332 @@
+---
+name: sf-tdd-workflow
+description: >-
+  Use when doing test-driven Salesforce Apex development — RED-GREEN-REFACTOR cycle for classes, triggers, and LWC Jest. Do NOT use for test patterns only.
+disable-model-invocation: true
+---
+
+# Salesforce TDD Workflow
+
+The test-driven development process adapted for the Salesforce platform. Test implementation patterns (mocks, factories, coverage strategies) live in `sf-apex-testing`. This skill covers the TDD _process_ — RED-GREEN-REFACTOR cycle and how to apply it to Apex, LWC, and Flows.
+
+Reference: @../_reference/TESTING_STANDARDS.md
+
+---
+
+## When to Use
+
+- When starting new Apex class or trigger development using the RED-GREEN-REFACTOR cycle
+- When writing LWC Jest tests before building component logic
+- When refactoring existing untested Apex code and needing a safety net
+- When establishing TDD practices and coverage targets for a team
+- When adding tests for a class below the 75% coverage deployment requirement
+
+> **Related:** For test implementation details (@TestSetup, mocks, bulk testing, coverage), see `sf-apex-testing`.
+
+---
+
+## Core Workflow: RED-GREEN-REFACTOR
+
+### Step 1: RED — Write Failing Tests First
+
+Write the test before the production code exists. The test should compile but fail.
+
+**Apex:**
+
+```apex
+@IsTest
+private class AccountServiceTest {
+
+    @TestSetup
+    static void makeData() {
+        Account acc = new Account(Name = 'Test Account', Industry = 'Technology');
+        insert acc;
+    }
+
+    @IsTest
+    static void shouldCalculateAnnualRevenue() {
+        Account acc = [SELECT Id FROM Account LIMIT 1];
+
+        Test.startTest();
+        Decimal revenue = AccountService.calculateAnnualRevenue(acc.Id);
+        Test.stopTest();
+
+        Assert.isNotNull(revenue, 'Revenue should not be null');
+        Assert.isTrue(revenue >= 0, 'Revenue should be non-negative');
+    }
+
+    @IsTest
+    static void shouldHandleNullInput() {
+        Test.startTest();
+        try {
+            AccountService.calculateAnnualRevenue(null);
+            Assert.fail('Should have thrown exception');
+        } catch (AccountService.AccountServiceException e) {
+            Assert.isTrue(e.getMessage().contains('Account Id'),
+                'Error should mention Account Id');
+        }
+        Test.stopTest();
+    }
+
+    @IsTest
+    static void shouldHandleBulkRecords() {
+        List<Account> accounts = new List<Account>();
+        for (Integer i = 0; i < 200; i++) {
+            accounts.add(new Account(Name = 'Bulk Test ' + i));
+        }
+        insert accounts;
+
+        Test.startTest();
+        List<Decimal> revenues = AccountService.calculateAnnualRevenueBulk(
+            new Map<Id, Account>(accounts).keySet()
+        );
+        Test.stopTest();
+
+        System.assertEquals(200, revenues.size(), 'Should process all 200 records');
+    }
+}
+```
+
+**LWC Jest:**
+
+```javascript
+import { createElement } from 'lwc';
+import AccountCard from 'c/accountCard';
+import getAccount from '@salesforce/apex/AccountController.getAccount';
+
+jest.mock('@salesforce/apex/AccountController.getAccount',
+    () => ({ default: jest.fn() }), { virtual: true });
+
+describe('c-account-card', () => {
+    afterEach(() => {
+        while (document.body.firstChild) document.body.removeChild(document.body.firstChild);
+    });
+
+    it('displays account name when data is loaded', async () => {
+        getAccount.mockResolvedValue({ Name: 'Acme Corp', Industry: 'Technology' });
+        const element = createElement('c-account-card', { is: AccountCard });
+        element.recordId = '001xx000003ABCDEF';
+        document.body.appendChild(element);
+
+        await Promise.resolve();
+        const nameEl = element.shadowRoot.querySelector('.account-name');
+        expect(nameEl.textContent).toBe('Acme Corp');
+    });
+});
+```
+
+### Step 2: GREEN — Implement Minimum Code
+
+Write only enough code to make the tests pass. No premature optimization.
+
+### Step 3: REFACTOR — Clean Up
+
+- Extract common patterns into utility classes
+- Apply enterprise patterns (Service Layer, Selector Layer) if warranted
+- Ensure bulkification
+- Run full test suite to verify no regressions
+
+---
+
+## Trigger TDD
+
+Create the handler class stub first (empty method signatures so the test compiles), then write the test, then implement the handler, then wire the trigger.
+
+```apex
+// RED: Write test for trigger handler
+@IsTest
+private class AccountTriggerHandlerTest {
+
+    @IsTest
+    static void shouldSetDefaultIndustryOnInsert() {
+        Account acc = new Account(Name = 'TDD Account');
+
+        Test.startTest();
+        insert acc;
+        Test.stopTest();
+
+        Account result = [SELECT Industry FROM Account WHERE Id = :acc.Id];
+        System.assertEquals('Other', result.Industry, 'Should default Industry to Other');
+    }
+
+    @IsTest
+    static void shouldNotOverrideExistingIndustry() {
+        Account acc = new Account(Name = 'TDD Account', Industry = 'Technology');
+
+        Test.startTest();
+        insert acc;
+        Test.stopTest();
+
+        Account result = [SELECT Industry FROM Account WHERE Id = :acc.Id];
+        System.assertEquals('Technology', result.Industry, 'Should keep existing Industry');
+    }
+}
+
+// GREEN: Implement handler
+public with sharing class AccountTriggerHandler {
+    public static void onBeforeInsert(List<Account> newAccounts) {
+        for (Account acc : newAccounts) {
+            if (acc.Industry == null) acc.Industry = 'Other';
+        }
+    }
+}
+
+// Wire trigger (last step)
+trigger AccountTrigger on Account (before insert) {
+    AccountTriggerHandler.onBeforeInsert(Trigger.new);
+}
+```
+
+---
+
+## Async TDD Patterns
+
+### Queueable TDD
+
+```apex
+@IsTest
+private class AccountEnrichmentJobTest {
+
+    @IsTest
+    static void shouldEnrichAccountsWithExternalData() {
+        Account acc = new Account(Name = 'Enrich Me', BillingCity = 'San Francisco');
+        insert acc;
+
+        Test.startTest();
+        System.enqueueJob(new AccountEnrichmentJob(new Set<Id>{ acc.Id }));
+        Test.stopTest(); // Forces Queueable to execute synchronously
+
+        Account result = [SELECT Description FROM Account WHERE Id = :acc.Id];
+        System.assertNotEquals(null, result.Description, 'Should have enrichment data');
+    }
+}
+```
+
+### Batch TDD
+
+```apex
+@IsTest
+private class DataCleanupBatchTest {
+
+    @IsTest
+    static void shouldDeactivateStaleAccounts() {
+        List<Account> accounts = new List<Account>();
+        for (Integer i = 0; i < 200; i++) {
+            accounts.add(new Account(Name = 'Stale ' + i));
+        }
+        insert accounts;
+
+        // Create old Tasks so LastActivityDate is set automatically
+        List<Task> oldTasks = new List<Task>();
+        for (Account acc : accounts) {
+            oldTasks.add(new Task(
+                WhatId = acc.Id, Subject = 'Old Activity',
+                ActivityDate = Date.today().addDays(-365), Status = 'Completed'
+            ));
+        }
+        insert oldTasks;
+
+        Test.startTest();
+        Database.executeBatch(new DataCleanupBatch(), 200);
+        Test.stopTest();
+
+        Integer activeCount = [SELECT COUNT() FROM Account
+            WHERE Active__c = 'Yes' AND Name LIKE 'Stale%'];
+        Assert.areEqual(0, activeCount, 'All stale accounts should be deactivated');
+    }
+}
+```
+
+---
+
+## Flow Testing in TDD
+
+Test Flows by triggering them through DML and verifying outcomes.
+
+```apex
+@IsTest
+private class OpportunityFlowTest {
+
+    @IsTest
+    static void shouldCreateFollowUpTaskWhenOppClosedWon() {
+        Account acc = new Account(Name = 'Flow Test');
+        insert acc;
+
+        Opportunity opp = new Opportunity(
+            AccountId = acc.Id, Name = 'Flow Test Opp',
+            StageName = 'Prospecting', CloseDate = Date.today().addDays(30)
+        );
+        insert opp;
+
+        Test.startTest();
+        opp.StageName = 'Closed Won';
+        update opp;
+        Test.stopTest();
+
+        List<Task> tasks = [SELECT Subject FROM Task WHERE WhatId = :opp.Id];
+        System.assert(!tasks.isEmpty(), 'Flow should have created a follow-up task');
+    }
+}
+```
+
+---
+
+## TDD in CI/CD Pipeline
+
+```yaml
+# GitHub Actions: Run TDD suite on every PR
+- name: Run Apex Tests and Check Coverage
+  run: |
+    sf apex run test \
+      --test-level RunLocalTests \
+      --code-coverage \
+      --result-format json \
+      --wait 15 \
+      --output-dir test-results \
+      --target-org ci-scratch
+
+    RESULT_FILE=$(ls test-results/test-run-*.json 2>/dev/null | head -1)
+    if [ -z "$RESULT_FILE" ]; then
+      echo "No test result file found"
+      exit 1
+    fi
+    COVERAGE=$(node -e "const r=JSON.parse(require('fs').readFileSync('$RESULT_FILE','utf8')); \
+      console.log(r.result?.summary?.orgWideCoverage?.replace('%',''))")
+    echo "Org-wide coverage: ${COVERAGE}%"
+    node -e "if (parseFloat('$COVERAGE') < 75) { process.exit(1); }"
+```
+
+---
+
+## Coverage Targets
+
+| Type | Minimum | Target |
+|------|---------|--------|
+| Apex Classes | 75% | 85%+ |
+| Apex Triggers | 75% | 90%+ |
+| LWC Components | N/A | 80%+ |
+| Integration Tests | N/A | Key paths |
+
+---
+
+## Common TDD Mistakes
+
+| Mistake | Problem | Fix |
+|---------|---------|-----|
+| Testing platform behavior | Tests Salesforce, not your code | Test business logic outcomes only |
+| Testing getters/setters | No business value | Skip trivial accessors |
+| No bulk test | Passes with 1 record, fails with 200 | Always include 200+ record test |
+| Hardcoded record IDs | Breaks across orgs | Use @TestSetup or TestDataFactory |
+| Skipping negative tests | Misses error handling gaps | Test invalid input, missing permissions |
+| Testing inside try/catch without re-throw | Test passes even when assertion fails | Use `Assert.fail('Should have thrown')` pattern |
+
+---
+
+## Related
+
+- **Agent**: `sf-apex-agent` — For interactive, in-depth guidance
+- **Skills**: `sf-apex-testing` — Test implementation patterns
+
+### Guardrails
+
+- `sf-testing-constraints` — Enforces test isolation, assertion requirements, SeeAllData prohibition, and coverage thresholds

package/.cursor/skills/sf-testing-constraints/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: sf-testing-constraints
+description: >-
+  Enforce Apex testing standards — 75% coverage minimum, test isolation, assertions, TestDataFactory. Use when writing or reviewing ANY Apex test class or method. Do NOT use for LWC Jest or Flow tests.
+---
+
+# Apex Testing Constraints
+
+## When to Use
+
+This skill auto-activates when writing, reviewing, or modifying any Apex test class or method. It enforces coverage minimums, test isolation, assertion requirements, and TestDataFactory patterns for all test artifacts.
+
+Hard rules for every Apex test class and method. Violating any NEVER rule is a blocking defect. Violating any ALWAYS rule requires justification in a code comment.
+
+Reference: @../_reference/TESTING_STANDARDS.md
+
+---
+
+## NEVER Rules
+
+These are non-negotiable. Flag violations immediately.
+
+### N1 — Never use `@isTest(SeeAllData=true)`
+
+Tests must create their own data. `SeeAllData=true` couples tests to org state and breaks on every sandbox refresh. **Sole exception:** Standard Pricebook tests (prefer `Test.getStandardPricebookId()` even then).
+
+```apex
+// VIOLATION
+@isTest(SeeAllData=true)
+private class BadTest { ... }
+
+// CORRECT
+@isTest
+private class GoodTest { ... }
+```
+
+### N2 — Never write a test without assertions
+
+A test method with zero assertions always passes and catches nothing. Every `@isTest` method must contain at least one meaningful assertion that verifies business logic, not just that DML succeeded.
+
+```apex
+// VIOLATION — no assertion
+@isTest
+static void testCreate() {
+    Account a = new Account(Name = 'X');
+    insert a;
+    // method ends without any assert
+}
+
+// CORRECT — asserts business outcome
+@isTest
+static void testCreate_setsDefaultTier() {
+    Account a = new Account(Name = 'X');
+    insert a;
+    Account result = [SELECT Customer_Tier__c FROM Account WHERE Id = :a.Id];
+    Assert.areEqual('Standard', result.Customer_Tier__c,
+        'Trigger should set default tier on insert');
+}
+```
+
+### N3 — Never hardcode Record IDs
+
+IDs differ between orgs, sandboxes, and scratch orgs. Hardcoded IDs cause silent test failures after a refresh.
+
+```apex
+// VIOLATION
+Id accountId = '0015g00000ABC12AAA';
+
+// CORRECT
+Account acc = TestDataFactory.createAccount();
+Id accountId = acc.Id;
+```
+
+### N4 — Never test only SOQL
+
+A test that queries records without exercising any service, trigger, or business logic method is not a test. It verifies that Salesforce can read its own database.
+
+```apex
+// VIOLATION — tests the platform, not your code
+@isTest
+static void testQuery() {
+    insert new Account(Name = 'X');
+    List<Account> accs = [SELECT Id FROM Account];
+    Assert.areEqual(1, accs.size());
+}
+```
+
+### N5 — Never use `System.debug` as a substitute for assertions
+
+Debug statements produce no test signal. They cannot fail and cannot catch regressions.
+
+### N6 — Never test multiple unrelated scenarios in one method
+
+One scenario per test method. Multi-scenario methods mask which scenario broke.
+
+---
+
+## ALWAYS Rules
+
+Required in every test class unless explicitly justified.
+
+### A1 — Always use `@TestSetup` for shared test data
+
+Runs once per class; each test method gets its own rollback. Omitting it duplicates DML and wastes governor limits.
+
+```apex
+@TestSetup
+static void makeData() {
+    Account acc = TestDataFactory.createAccount();
+    TestDataFactory.createOpportunity(acc.Id);
+}
+```
+
+### A2 — Always use TestDataFactory
+
+All test record creation goes through a centralized `TestDataFactory` class. Inline `new SObject(...)` / `insert` is acceptable only for one-off scenario overrides the factory cannot express. Single maintenance point, override maps, consistent defaults.
+
+### A3 — Always assert positive AND negative cases
+
+Every service method needs at least:
+
+- One positive test (valid input produces expected output)
+- One negative test (invalid input throws expected exception or returns expected error)
+
+```apex
+// Positive
+@isTest
+static void testUpgrade_validAccount_succeeds() { ... }
+
+// Negative
+@isTest
+static void testUpgrade_insufficientRevenue_throwsException() { ... }
+```
+
+### A4 — Always include a bulk test with 200+ records
+
+200 is the standard trigger batch size. Code that passes with 1 record can hit governor limits at 200. Every trigger handler and service method operating on collections must have a 200-record test.
+
+```apex
+@isTest
+static void testHandler_bulkInsert_200Records_noLimitException() {
+    List<Account> accounts = TestDataFactory.createAccounts(200);
+    // Trigger already fired on insert; verify outcomes
+    Assert.areEqual(200,
+        [SELECT COUNT() FROM Account WHERE Customer_Tier__c = 'Standard'],
+        'All 200 accounts should have default tier set');
+}
+```
+
+### A5 — Always use `Test.startTest()` / `Test.stopTest()`
+
+Resets governor limit counters and forces async work (@future, Queueable, Batch) to execute synchronously. One pair per test method.
+
+### A6 — Always use descriptive test method names
+
+Format: `test{MethodName}_{scenario}_{expectedResult}` (e.g., `testCalculateDiscount_premiumTier_returns20Percent`).
+
+### A7 — Always add `@testFor` on test classes (see @../_reference/API_VERSIONS.md for minimum version)
+
+Maps test classes to production classes for `RunRelevantTests`. Missing `@testFor` means the test may be skipped on relevant changes.
+
+---
+
+## Anti-Pattern Quick Reference
+
+| # | Anti-Pattern | Why It Breaks | Required Fix |
+|---|---|---|---|
+| N1 | `SeeAllData=true` | Fails on sandbox refresh; couples test to org data | Create test data via TestDataFactory |
+| N2 | No assertions | Test always passes; catches zero regressions | Add `Assert.areEqual` / `Assert.isTrue` for business logic |
+| N3 | Hardcoded Record IDs | IDs differ between orgs | Query or create records in test |
+| N4 | SOQL-only test | Tests the platform, not your code | Exercise a service/trigger method, then assert outcomes |
+| N5 | `System.debug` instead of assert | No test signal; cannot fail | Replace with assertions |
+| N6 | One method, 10 scenarios | Masks which scenario fails | One scenario per test method |
+| A1 | No `@TestSetup` | Duplicated DML, wasted governor limits | Add `@TestSetup` with TestDataFactory calls |
+| A2 | Inline record creation | Maintenance burden when fields change | Use TestDataFactory with override maps |
+| A3 | Only happy-path tests | Error handling never verified | Add negative-case tests |
+| A4 | No bulk test | Governor limit violations hidden | Test with 200 records |
+| A5 | Missing `startTest/stopTest` | Governor limits not reset; async not executed | Wrap code under test in the pair |
+| A6 | Vague method names | Cannot identify failing scenario from name | Use `test{Method}_{scenario}_{expected}` format |
+| A7 | Missing `@testFor` | `RunRelevantTests` may skip the test | Add `@testFor(ClassName)` annotation |
+
+---
+
+## Coverage Targets
+
+| Context | Minimum | Recommended |
+|---|---|---|
+| Production deployment (org-wide) | 75% | 85%+ per class |
+| Managed package (AppExchange) | 75% | 90%+ per class |
+| Triggers | 75% | 90%+ |
+
+Coverage measures lines executed, not branches. Test every branch, not just every line.
+
+## Related
+
+- `sf-apex-testing` — Full test implementation patterns (mocks, async, permissions)
+- `sf-tdd-workflow` — RED-GREEN-REFACTOR process and TDD workflow
+- @../_reference/TESTING_STANDARDS.md — Platform testing standards (see @../_reference/API_VERSIONS.md)

package/.cursor/skills/sf-trigger-constraints/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: sf-trigger-constraints
+description: >-
+  Enforce one-trigger-per-object, handler delegation, bulkification, and recursion prevention. Use when writing or reviewing ANY Apex trigger or handler. Do NOT use for non-trigger Apex, LWC, or Flow.
+---
+
+# Trigger Constraints
+
+## When to Use
+
+This skill auto-activates when writing, reviewing, or modifying any Apex trigger or trigger handler. It enforces one-trigger-per-object, handler delegation, bulkification, and recursion prevention rules for all trigger artifacts.
+
+Hard rules that every Apex trigger and trigger handler must satisfy. Violations are blockers -- flag them before any other review feedback.
+
+Reference: @../_reference/TRIGGER_PATTERNS.md (order of execution, context variables, framework comparison).
+
+---
+
+## Never Rules
+
+These are absolute prohibitions. Any occurrence is a defect.
+
+| ID | Rule | Why |
+|----|------|-----|
+| N1 | **No logic in the trigger body** | Trigger files contain only the handler invocation (`new Handler().run()` or `fflib_SObjectDomain.triggerHandler(Domain.class)`). Zero conditionals, zero loops, zero DML. |
+| N2 | **No multiple triggers per object** | Multiple triggers on the same sObject have no guaranteed execution order (see @../_reference/TRIGGER_PATTERNS.md, Step 5/9). Consolidate into one trigger file per object. |
+| N3 | **No DML inside loops** | `insert`/`update`/`delete`/`upsert`/`Database.*` calls inside `for` loops hit governor limits. Collect records first, DML once outside the loop. |
+| N4 | **No SOQL inside loops** | Queries inside `for` loops risk the per-transaction SOQL limit (see @../_reference/GOVERNOR_LIMITS.md). Query before the loop, store results in a `Map<Id, SObject>`. |
+| N5 | **No hardcoded IDs** | Record IDs, profile IDs, or record-type IDs must never appear as string literals. Use `Schema.SObjectType.*.getRecordTypeInfosByDeveloperName()`, Custom Metadata, or Custom Labels. |
+| N6 | **No direct callouts** | Apex triggers cannot make HTTP callouts synchronously. Use `@future(callout=true)` or `Queueable` with `Database.AllowsCallouts`. |
+| N7 | **No `Trigger.new` modification in after triggers** | `Trigger.new` is read-only in after contexts. Field updates in after triggers must go through a separate DML statement on queried/cloned records. |
+
+---
+
+## Always Rules
+
+Every trigger implementation must include these elements.
+
+| ID | Rule | How |
+|----|------|-----|
+| A1 | **Delegate to a handler class** | Trigger body calls handler: `new AccountTriggerHandler().run();`. All logic lives in the handler or in service classes the handler calls. |
+| A2 | **Bulkify all logic** | Every method must handle `List<SObject>` (up to 200 records per chunk). No assumption of single-record input. Iterate `Trigger.new` / `Trigger.old`, never index `[0]` alone. |
+| A3 | **Use a recursion guard** | Prevent infinite re-entry. Recommended: static `Set<Id>` of processed IDs (allows workflow re-fire for unprocessed records while blocking true recursion). Alternatives: depth counter in base class, `setMaxLoopCount()`. See @../_reference/TRIGGER_PATTERNS.md recursion patterns. |
+| A4 | **Use `Trigger.newMap` / `Trigger.oldMap` for comparisons** | When detecting field changes in update triggers, compare `Trigger.newMap.get(id).Field__c` against `Trigger.oldMap.get(id).Field__c`. Never rely on list index alignment. |
+| A5 | **Register all events in one trigger** | The single trigger file should subscribe to all seven events (`before insert, before update, before delete, after insert, after update, after delete, after undelete`) even if the handler only overrides a subset today. This prevents needing a trigger file redeploy when new events are handled later. |
+| A6 | **Include a bypass mechanism** | Support disabling the handler without a code deploy. Use `TriggerHandler.bypass()` / `.clearBypass()`, Custom Metadata (`Trigger_Setting__mdt`), or Hierarchy Custom Settings. Always reset bypass state in a `finally` block. |
+| A7 | **Keep handler methods focused** | Each `onBeforeInsert()`, `onAfterUpdate()`, etc. should call named service methods. If a handler method exceeds ~30 lines, extract to a service class. |
+
+---
+
+## Anti-Pattern Table
+
+| Anti-Pattern | Example | Correct Alternative |
+|---|---|---|
+| Logic in trigger body | `trigger T on Account (before insert) { for (Account a : Trigger.new) { a.Name = 'X'; } }` | `trigger T on Account (...) { new AccountTriggerHandler().run(); }` with logic in handler |
+| Two triggers on same object | `AccountTrigger.trigger` + `AccountOwnerTrigger.trigger` | Single `AccountTrigger.trigger` delegating to one handler |
+| DML in loop | `for (Account a : accts) { update a; }` | `update accts;` outside loop |
+| SOQL in loop | `for (Account a : accts) { Contact c = [SELECT ...]; }` | `Map<Id, Contact> cMap = new Map<Id, Contact>([SELECT ...]); // before loop` |
+| Hardcoded ID | `if (acc.RecordTypeId == '012000000000001')` | `Schema.SObjectType.Account.getRecordTypeInfosByDeveloperName().get('Customer').getRecordTypeId()` |
+| No recursion guard | After-update handler updates same records with no static check | `private static Set<Id> processedIds = new Set<Id>();` -- skip IDs already in set |
+| Boolean recursion flag | `static Boolean hasRun = false; if (hasRun) return;` | `Set<Id>` -- boolean flag blocks legitimate workflow re-fire for unprocessed records |
+| Modifying `Trigger.new` in after context | `for (Account a : Trigger.new) { a.Status__c = 'Done'; }` in `onAfterInsert` | Query records, update separately: `update [SELECT Id FROM Account WHERE Id IN :newMap.keySet()]` |
+
+---
+
+## Quick Checklist
+
+Use when writing or reviewing a trigger PR:
+
+- [ ] Exactly one `.trigger` file per sObject
+- [ ] Trigger body is a single handler call (no logic)
+- [ ] Handler extends `TriggerHandler` (or FFLIB `fflib_SObjectDomain`)
+- [ ] All seven events registered in trigger definition
+- [ ] Every loop processes `List<SObject>`, not a single record
+- [ ] Zero SOQL or DML inside any loop
+- [ ] No hardcoded IDs anywhere
+- [ ] Recursion guard present (prefer `Set<Id>` pattern)
+- [ ] Bypass mechanism available
+- [ ] No `Trigger.new` mutation in after-trigger methods
+- [ ] No synchronous callouts
+
+---
+
+## Related
+
+- **Skill**: `sf-trigger-frameworks` -- Framework patterns, base class code, migration guide
+- **Reference**: @../_reference/TRIGGER_PATTERNS.md -- Order of execution, context variables, framework comparison
+- **Agent**: `sf-architect` -- Interactive trigger design guidance