@salesforce/afv-skills 1.21.0 → 1.23.0

package/skills/platform-apex-logs-debug/references/log-analysis-tools.md

@@ -0,0 +1,248 @@
+<!-- Parent: platform-apex-logs-debug/SKILL.md -->
+# Log Analysis Tools
+
+This guide covers tools for analyzing Salesforce debug logs, with a focus on performance profiling and bottleneck identification.
+
+---
+
+## Recommended: Apex Log Analyzer (VS Code)
+
+The **Apex Log Analyzer** is a free VS Code extension that provides visual analysis of Apex debug logs.
+
+### Installation
+
+```
+1. Open VS Code
+2. Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
+3. Search "Apex Log Analyzer"
+4. Install "Apex Log Analyzer" by FinancialForce
+```
+
+Or install via command line:
+```bash
+code --install-extension FinancialForce.lana
+```
+
+### Key Features
+
+| Feature | Description | Use Case |
+|---------|-------------|----------|
+| **Flame Charts** | Visual execution timeline | Find slow methods at a glance |
+| **Call Tree** | Hierarchical method calls | Trace execution paths |
+| **Database Analysis** | SOQL/DML highlighting | Find query hotspots |
+| **Timeline View** | Execution over time | See parallel operations |
+| **Limit Summary** | Governor limit usage | Quick health check |
+
+### How to Use
+
+1. **Get a debug log**:
+   ```bash
+   sf apex get log --log-id 07Lxx0000000000 --target-org my-sandbox -o debug.log
+   ```
+
+2. **Open in VS Code**:
+   - Open the `.log` file
+   - Click "Analyze Log" button in the editor toolbar
+   - Or use Command Palette: "Apex Log: Analyze Log"
+
+3. **Navigate the visualization**:
+   - **Flame Chart**: Wider bars = more time spent
+   - **Click methods** to see details
+   - **Hover** for exact timing
+   - **Filter** to focus on specific operations
+
+### Reading Flame Charts
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ FLAME CHART INTERPRETATION                                   │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  ████████████████████████████████████  AccountTrigger       │
+│    ██████████████████  AccountService.processAccounts       │
+│      ██████████  ← BOTTLENECK: Wide bar = slow operation    │
+│        ████  SOQL query                                      │
+│      ████████████  Another slow method                       │
+│                                                              │
+│  Time flows left → right                                     │
+│  Width = execution time                                      │
+│  Stack depth = call hierarchy                                │
+│                                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Bottleneck Indicators**:
+- Wide bars at lower levels (deep in call stack)
+- Multiple identical bars (repeated operations)
+- SOQL/DML bars inside loop patterns
+
+---
+
+## SF CLI Debug Commands
+
+### List Available Logs
+
+```bash
+# List recent logs
+sf apex list log --target-org my-sandbox --json
+
+# Output includes:
+# - Log ID
+# - Start time
+# - Operation type
+# - User
+# - Size
+```
+
+### Download Logs
+
+```bash
+# Download specific log
+sf apex get log --log-id 07Lxx0000000000 --target-org my-sandbox
+
+# Save to file
+sf apex get log --log-id 07Lxx0000000000 --target-org my-sandbox > debug.log
+
+# Download with number
+sf apex get log --number 1 --target-org my-sandbox  # Most recent
+```
+
+### Real-Time Log Streaming
+
+```bash
+# Tail logs in real-time (like `tail -f`)
+sf apex tail log --target-org my-sandbox
+
+# With color highlighting
+sf apex tail log --target-org my-sandbox --color
+
+# Use an existing debug level when setting the trace flag
+sf apex tail log --target-org my-sandbox --debug-level MyDebugLevel
+
+# Skip trace flag setup when a trace flag is already configured
+sf apex tail log --target-org my-sandbox --skip-trace-flag
+```
+
+### Set Debug Level
+
+```bash
+# Create trace flag via SFDX
+sf data create record \
+  --sobject TraceFlag \
+  --values "TracedEntityId='005xx...' LogType='USER_DEBUG' StartDate='2024-01-01T00:00:00' ExpirationDate='2024-01-02T00:00:00'" \
+  --target-org my-sandbox
+```
+
+---
+
+## Manual Log Analysis (grep/ripgrep)
+
+When you need quick analysis without visual tools:
+
+### Find All SOQL Queries
+
+```bash
+# Count SOQL queries
+rg "SOQL_EXECUTE_BEGIN" debug.log | wc -l
+
+# See query text
+rg "SOQL_EXECUTE_BEGIN" debug.log
+
+# Find SOQL in loops (query appears multiple times on same line)
+rg "SOQL_EXECUTE_BEGIN" debug.log | sort | uniq -c | sort -rn | head -10
+```
+
+### Find Large Result Sets
+
+```bash
+# Find queries returning many rows
+rg "SOQL_EXECUTE_END.*\[\d{4,} rows\]" debug.log
+```
+
+### Check Governor Limits
+
+```bash
+# Find limit snapshots
+rg "LIMIT_USAGE" debug.log | tail -20
+
+# Find approaching limits (>80%)
+rg "CPU_TIME" debug.log | tail -5
+rg "HEAP_SIZE" debug.log | tail -5
+```
+
+### Find Exceptions
+
+```bash
+# Find all exceptions
+rg "EXCEPTION_THROWN|FATAL_ERROR" debug.log
+
+# Get stack traces
+rg -A 10 "FATAL_ERROR" debug.log
+```
+
+### Find Slow Operations
+
+```bash
+# Extract all timing info
+rg "\[\d+\]ms" debug.log | sort -t'[' -k2 -rn | head -20
+```
+
+---
+
+## Developer Console Analysis
+
+For quick checks directly in Salesforce:
+
+### Query Plan Tool
+
+1. Open Developer Console
+2. Query Editor tab
+3. Click "Query Plan" checkbox
+4. Run your query
+5. Review selectivity and cost
+
+### Log Inspector
+
+1. Open Developer Console
+2. Debug → Open Execute Anonymous Window
+3. Run code to generate log
+4. Select log in "Logs" tab
+5. Debug → View Log Panels
+
+**Useful Panels**:
+- **Execution Overview**: Summary of operations
+- **Timeline**: Visual execution flow
+- **Stack Tree**: Call hierarchy
+- **Database**: SOQL/DML details
+
+---
+
+## Quick Reference: What to Look For
+
+| Problem | What to Search | Pattern |
+|---------|----------------|---------|
+| SOQL in Loop | `SOQL_EXECUTE_BEGIN` | Same query repeated many times |
+| DML in Loop | `DML_BEGIN` | Same DML repeated many times |
+| Slow Query | `SOQL_EXECUTE_END` | Large row count |
+| CPU Issue | `CPU_TIME` | Approaching 10,000ms |
+| Heap Issue | `HEAP_SIZE` | Approaching 6,000,000 |
+| Exception | `EXCEPTION_THROWN` | Stack trace |
+
+---
+
+## Comparison: Analysis Tools
+
+| Tool | Pros | Cons | Best For |
+|------|------|------|----------|
+| **Apex Log Analyzer** | Visual, free, flame charts | Requires VS Code | Deep performance analysis |
+| **Developer Console** | Built-in, no install | Limited visualization | Quick checks |
+| **SF CLI + grep** | Scriptable, fast | No visualization | CI/CD, automation |
+| **Salesforce Inspector** | Browser-based | Limited log analysis | Quick org exploration |
+
+---
+
+## Related Resources
+
+- [debug-log-reference.md](./debug-log-reference.md) - Log event types
+- [benchmarking-guide.md](./benchmarking-guide.md) - Performance testing
+- [cli-commands.md](./cli-commands.md) - SF CLI reference

package/skills/platform-apex-test-generate/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: platform-apex-test-generate
+description: "Generate and validate Apex test classes with TestDataFactory patterns, bulk testing (251+ records), mocking strategies, assertion best practices, and disciplined test-fix loops. Use this skill when creating new Apex test classes, improving test coverage, debugging and fixing failing Apex tests, running test execution and coverage analysis, or implementing testing patterns for triggers, services, controllers, batch jobs, queueables, and integrations. Triggers on *Test.cls, *_Test.cls files, sf apex run test workflows, coverage reports, test-fix loops. Do NOT trigger for production Apex code (use platform-apex-generate) or Jest/LWC tests."
+metadata:
+  version: "1.0"
+---
+
+# Generating Apex Tests
+
+Generate production-ready Apex test classes and run disciplined test-fix loops with coverage analysis.
+
+## Core Principles
+
+1. **One behavior per method** — each test method validates a single scenario. Separate positive, negative, and bulk tests. NEVER combine related-but-distinct inputs (e.g., null and empty) in one method — create `_NullInput_` and `_EmptyInput_` as separate test methods
+2. **Bulkify tests** — test with 251+ records to cross the 200-record trigger batch boundary. **Batch Apex exception:** in test context only one `execute()` invocation runs, so set `batchSize >= testRecordCount`. See [references/async-testing.md](references/async-testing.md)
+3. **Isolate test data** — every `@TestSetup` must delegate record creation to a `TestDataFactory` class. If none exists, create one first. Never build record lists inline in `@TestSetup`. Never rely on org data (`SeeAllData=false`) or hardcoded IDs. For duplicate rule handling, see [references/test-data-factory.md](references/test-data-factory.md)
+4. **Assert meaningfully** — use exact expected values computed from test data setup. NEVER use range assertions or approximate counts when the value is deterministic. Always include failure messages. See [references/assertion-patterns.md](references/assertion-patterns.md)
+5. **Use `Assert` class only** — `Assert.areEqual`, `Assert.isTrue`, `Assert.fail`, etc. Never use legacy `System.assert`, `System.assertEquals`, or `System.assertNotEquals`
+6. **Mock external boundaries** — use `HttpCalloutMock` for callouts, `Test.setFixedSearchResults` for SOSL, DML mock classes for database isolation. Design for testability via constructor injection. See [references/mocking-patterns.md](references/mocking-patterns.md)
+7. **Test negative paths** — validate error handling and exception scenarios, not just happy paths
+8. **Wrap with start/stop** — pair `Test.startTest()` with `Test.stopTest()` to reset governor limits and force async execution
+
+## Test.startTest() / Test.stopTest()
+
+Always wrap the code under test in `Test.startTest()` / `Test.stopTest()`:
+
+- Resets governor limits so the test measures only the code under test
+- Executes async operations synchronously (queueables, batch, future methods)
+- Fires scheduled jobs immediately
+
+## Test Code Anti-Patterns
+
+| Anti-Pattern | Fix |
+|---|---|
+| SOQL/DML inside loops | Query once before the loop; use `Map<Id, SObject>` for lookups |
+| Magic numbers in assertions | Derive expected values from setup constants |
+| God test class (>500 lines) | Split into multiple test classes by behavior area |
+| Long test methods (>30 lines) | Extract Given/When/Then into helper methods |
+| Generic `Exception` catch | Catch the specific expected type (e.g., `DmlException`) |
+
+## Workflow
+
+### Step 1 — Gather Context
+
+Before generating or fixing tests, identify:
+
+- the target production class(es) under test
+- existing test classes, test data factories, and setup helpers
+- desired test scope (single class, specific methods, suite, or local tests)
+- coverage threshold (75% minimum for deploy, 90%+ recommended)
+- org alias when running tests against an org
+
+### Step 2 — Generate the Test Class
+
+Apply the structure, naming conventions, and patterns from the asset templates and reference docs.
+
+**MANDATORY — File Deliverables:** For every test class, create BOTH files:
+1. `{ClassName}Test.cls` — the test class (use [assets/test-class-template.cls](assets/test-class-template.cls) as starting point)
+2. `{ClassName}Test.cls-meta.xml` — the metadata file:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
+    <apiVersion>66.0</apiVersion>
+    <status>Active</status>
+</ApexClass>
+```
+
+If no `TestDataFactory` exists in the project, create `TestDataFactory.cls` + `TestDataFactory.cls-meta.xml` using [assets/test-data-factory-template.cls](assets/test-data-factory-template.cls).
+
+#### @TestSetup Example
+
+```apex
+@TestSetup
+static void setupTestData() {
+    List<Account> accounts = TestDataFactory.createAccounts(251, true);
+}
+```
+
+#### Test Method Structure
+
+Use Given/When/Then:
+
+```apex
+@isTest
+static void shouldUpdateStatus_WhenValidInput() {
+    // Given
+    List<Account> accounts = [SELECT Id FROM Account];
+
+    // When
+    Test.startTest();
+    MyService.processAccounts(accounts);
+    Test.stopTest();
+
+    // Then
+    List<Account> updated = [SELECT Id, Status__c FROM Account];
+    Assert.areEqual(251, updated.size(), 'All accounts should be processed');
+}
+```
+
+#### Negative Test — Exception Pattern
+
+Use try/catch with `Assert.fail` to verify expected exceptions:
+
+```apex
+@isTest
+static void shouldThrowException_WhenInvalidInput() {
+    // Given
+    List<Account> emptyList = new List<Account>();
+
+    // When/Then
+    Test.startTest();
+    try {
+        MyService.processAccounts(emptyList);
+        Assert.fail('Expected MyCustomException to be thrown');
+    } catch (MyCustomException e) {
+        Assert.isTrue(e.getMessage().contains('cannot be empty'),
+            'Exception message should indicate empty input');
+    }
+    Test.stopTest();
+}
+```
+
+#### Naming Convention
+
+- `should[ExpectedResult]_When[Scenario]`: `shouldSendNotification_WhenOpportunityClosedWon`
+- `[SubjectOrAction]_[Scenario]_[ExpectedResult]`: `AccountUpdate_ChangeName_Success`
+
+### Step 3 — Run Tests
+
+Start narrow when debugging; widen after the fix is stable.
+
+```bash
+# Single test class
+sf apex run test --class-names MyServiceTest --result-format human --code-coverage --target-org <alias>
+
+# Specific test methods
+sf apex run test --tests MyServiceTest.shouldUpdateStatus_WhenValidInput --result-format human --target-org <alias>
+
+# All local tests
+sf apex run test --test-level RunLocalTests --result-format human --code-coverage --target-org <alias>
+```
+
+### Step 4 — Analyze Results
+
+Focus on:
+
+- failing methods — exception types and stack traces
+- uncovered lines and weak coverage areas
+- whether failures indicate bad test data, brittle assertions, or broken production logic
+
+### Step 5 — Fix Loop
+
+When tests fail, run a disciplined fix loop (max 3 iterations — stop and surface root cause if still failing):
+
+1. Read the failing test class and the class under test
+2. Identify root cause from error messages and stack traces
+3. Apply fix — adjust test data or assertions for test-side issues; delegate production code issues to the `platform-apex-generate` skill
+4. Rerun the focused test before broader regression
+5. Repeat until all tests pass, iteration limit reached, or root cause requires design change
+
+### Step 6 — Validate Coverage
+
+| Level | Coverage | Purpose |
+|-------|----------|---------|
+| Production deploy | 75% minimum | Required by Salesforce |
+| Recommended | 90%+ | Best practice target |
+| Critical paths | 100% | Business-critical code |
+
+Cover all paths: positive, negative/exception, bulk (251+ records), callout/async.
+
+## What to Test by Component
+
+| Component | Key Test Scenarios |
+|-----------|-------------------|
+| Trigger | Bulk insert/update/delete, recursion guard, field change detection |
+| Service | Valid/invalid inputs, bulk operations, exception handling |
+| Controller | Page load, action methods, view state |
+| Batch | start/execute/finish, scope matching (batch size >= record count), `Database.Stateful` tracking, error handling, chaining (separate methods — `finish()` calling `Database.executeBatch()` throws `UnexpectedException`) |
+| Queueable | Chaining (only first job runs in tests), bulkification, error handling, callout mocks before `Test.startTest()` |
+| Callout | Success response, error response, timeout |
+| Selector | Valid/null/empty inputs, bulk (251+), field population, sort order, `WITH USER_MODE` via `System.runAs` |
+| Scheduled | Direct execution via `execute(null)`, CRON registration via `CronTrigger` query |
+| Platform Event | `Test.enableChangeDataCapture()`, `Test.getEventBus().deliver()`, verify subscriber side effects |
+
+## Output Expectations
+
+Deliverables per test class:
+- `{ClassName}Test.cls` + `{ClassName}Test.cls-meta.xml` (match API version of class under test; default `66.0`)
+- `TestDataFactory.cls` + `TestDataFactory.cls-meta.xml` (if not already present)
+
+## Reference Files
+
+Load on demand for detailed patterns:
+
+| Reference | When to use |
+|-----------|-------------|
+| [references/test-data-factory.md](references/test-data-factory.md) | TestDataFactory patterns, field overrides, duplicate rule handling |
+| [references/assertion-patterns.md](references/assertion-patterns.md) | Assertion best practices, anti-patterns, common pitfalls |
+| [references/mocking-patterns.md](references/mocking-patterns.md) | HttpCalloutMock, DML mocking, StubProvider, SOSL, Email, Platform Events |
+| [references/async-testing.md](references/async-testing.md) | Batch, Queueable, Future, Scheduled job testing |

package/skills/platform-apex-test-run/README.md

@@ -0,0 +1,94 @@
+# platform-apex-test-run
+
+Comprehensive Salesforce testing skill with test execution, code coverage analysis, and agentic test-fix loops. Run tests, analyze coverage, and automatically fix failing tests.
+
+## Features
+
+- **Test Execution**: Run Apex tests via sf CLI with coverage analysis
+- **Coverage Analysis**: Parse reports, identify untested code paths
+- **Failure Analysis**: Parse failures, identify root causes, suggest fixes
+- **Agentic Test-Fix Loop**: Automatically fix failing tests and re-run
+- **120-Point Scoring**: Validation across 6 categories
+- **Bulk Testing**: Validate with 251+ records for governor limits
+
+## Quick Start
+
+### 1. Invoke the skill
+
+```
+Skill: platform-apex-test-run
+Request: "Run all tests and show coverage report for org dev"
+```
+
+### 2. Common operations
+
+| Operation | Example Request |
+|-----------|-----------------|
+| Run class | "Run AccountServiceTest in org dev" |
+| Run all | "Run all local tests with coverage" |
+| Coverage report | "Show code coverage for AccountService" |
+| Fix loop | "Run tests and fix failures automatically" |
+| Generate tests | "Create tests for AccountService class" |
+
+## Key Commands
+
+```bash
+# Run single test class
+sf apex run test --class-names MyClassTest --code-coverage --result-format json --target-org [alias]
+
+# Run all local tests
+sf apex run test --test-level RunLocalTests --code-coverage --result-format json --target-org [alias]
+
+# Run specific methods
+sf apex run test --tests MyClassTest.testMethod1 --target-org [alias]
+
+# Run with output directory
+sf apex run test --class-names MyClassTest --output-dir test-results --target-org [alias]
+```
+
+## Scoring System (120 Points)
+
+| Category | Points | Focus |
+|----------|--------|-------|
+| Coverage | 25 | Overall and per-class coverage |
+| Assertions | 25 | Meaningful assertions, edge cases |
+| Bulk Testing | 20 | 251+ records, governor limits |
+| Data Isolation | 20 | @TestSetup, test data factories |
+| Negative Tests | 15 | Error paths, exceptions |
+| Documentation | 15 | Test descriptions, clear naming |
+
+## Test Thresholds
+
+| Level | Coverage | Purpose |
+|-------|----------|---------|
+| Production | 75% minimum | Required for deployment |
+| Recommended | 90%+ | Best practice target |
+| Critical paths | 100% | Business-critical code |
+
+## Cross-Skill Integration
+
+| Related Skill | When to Use |
+|---------------|-------------|
+| sf-apex | Fix failing Apex code |
+| platform-apex-logs-debug | Analyze test failures with debug logs |
+| platform-data-manage | Generate 251+ bulk test records |
+| platform-metadata-deploy | Validate before deployment |
+
+## Agentic Test-Fix Loop
+
+When enabled, the skill will:
+1. Run tests and capture failures
+2. Analyze error messages and stack traces
+3. Generate fixes for common issues
+4. Apply fixes and re-run tests
+5. Repeat until all tests pass or max iterations reached
+
+## Documentation
+
+- [Testing Best Practices](references/testing-best-practices.md)
+
+## Requirements
+
+- sf CLI v2
+- Target Salesforce org
+- Test classes in org or local project

package/skills/platform-apex-test-run/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: platform-apex-test-run
+description: "Apex test execution, coverage analysis, and test-fix loops with 120-point scoring. Use when the user needs to run Apex tests, check code coverage, fix failing tests, or work with *Test.cls / *_Test.cls files. TRIGGER when: user runs Apex tests, checks code coverage, fixes failing tests, or touches *Test.cls / *_Test.cls files. DO NOT TRIGGER when: writing Apex production code (use platform-apex-generate), Agentforce agent testing (use agentforce-test), or Jest/LWC tests (use experience-lwc-generate)."
+metadata:
+  version: "1.1"
+---
+
+# platform-apex-test-run: Salesforce Test Execution & Coverage Analysis
+
+Use this skill when the user needs **Apex test execution and failure analysis**: running tests, checking coverage, interpreting failures, improving coverage, and managing a disciplined test-fix loop for Salesforce code.
+
+## When This Skill Owns the Task
+
+Use `platform-apex-test-run` when the work involves:
+- `sf apex run test` workflows
+- Apex unit-test failures
+- code coverage analysis
+- identifying uncovered lines and missing test scenarios
+- structured test-fix loops for Apex code
+
+Delegate elsewhere when the user is:
+- writing or refactoring production Apex → `platform-apex-generate` skill
+- testing Agentforce agents → `agentforce-test` skill
+- testing LWC with Jest → [experience-lwc-generate](../experience-lwc-generate/SKILL.md)
+
+---
+
+## Required Context to Gather First
+
+Ask for or infer:
+- target org alias
+- desired test scope: single class, specific methods, suite, or local tests
+- coverage threshold expectation
+- whether the user wants diagnosis only or a test-fix loop
+- whether related test data factories already exist
+
+---
+
+## Recommended Workflow
+
+### 1. Discover test scope
+Identify:
+- existing test classes
+- target production classes
+- test data factories / setup helpers
+
+### 2. Run the smallest useful test set first
+Start narrow when debugging a failure; widen only after the fix is stable.
+
+### 3. Analyze results
+Focus on:
+- failing methods
+- exception types and stack traces
+- uncovered lines / weak coverage areas
+- whether failures indicate bad test data, brittle assertions, or broken production logic
+
+### 4. Run a disciplined fix loop
+When the issue is code or test quality:
+- delegate code fixes to `platform-apex-generate` skill when needed
+- add or improve tests
+- rerun focused tests before broader regression
+
+### 5. Improve coverage intentionally
+Cover:
+- positive path
+- negative / exception path
+- bulk path (251+ records where appropriate)
+- callout or async path when relevant
+
+---
+
+## High-Signal Rules
+
+| Rule | Rationale |
+|------|-----------|
+| Default to `SeeAllData=false` | Ensures test isolation; prevents reliance on org-specific data |
+| Every test must assert meaningful outcomes | Tests with no assertions prove nothing and give false confidence |
+| Test bulk behavior with 251+ records | Triggers process in batches of 200; 251 records crosses the boundary |
+| Use factories / `@TestSetup` when they improve clarity | Consistent data creation in one place; rolled back between test methods |
+| Pair `Test.startTest()` with `Test.stopTest()` for async | Ensures async operations (queueable, future) complete before assertions |
+| Do not hide flaky org dependencies inside tests | Prevents intermittent failures tied to org state |
+
+---
+
+## Gotchas
+
+| Issue | Resolution |
+|-------|------------|
+| Test passes locally but fails in CI org | Check for `SeeAllData=true` or undeclared dependencies on org-specific records |
+| Coverage drops unexpectedly after refactor | Run focused class-level tests first, then widen to `RunLocalTests` to confirm |
+| "Uncommitted work pending" error in callout test | DML and HTTP callouts cannot be mixed in the same test context without `Test.startTest()` wrapping |
+| Mock not taking effect in test | Ensure `Test.setMock()` is called before the code that makes the callout |
+| `@TestSetup` data missing in test method | `@TestSetup` data is committed per test method — re-query it; do not store in static variables |
+
+---
+
+## Output Format
+
+When finishing, report in this order:
+1. **What tests were run**
+2. **Pass/fail summary**
+3. **Coverage result**
+4. **Root-cause findings**
+5. **Fix or next-run recommendation**
+
+Suggested shape:
+
+```text
+Test run: <scope>
+Org: <alias>
+Result: <passed / partial / failed>
+Coverage: <percent / key classes>
+Issues: <highest-signal failures>
+Next step: <fix class, add test, rerun scope, or widen regression>
+```
+
+---
+
+## Cross-Skill Integration
+
+| Need | Delegate to | Reason |
+|------|-------------|--------|
+| Fix production code or author test classes | `platform-apex-generate` skill | Code generation and repair |
+| Create bulk / edge-case test data | [platform-data-manage](../platform-data-manage/SKILL.md) | Realistic test datasets |
+| Deploy updated tests to org | [platform-metadata-deploy](../platform-metadata-deploy/SKILL.md) | Deployment workflows |
+| Inspect detailed runtime logs | [platform-apex-logs-debug](../platform-apex-logs-debug/SKILL.md) | Deeper failure analysis |
+
+---
+
+## Reference File Index
+
+| File | When to read |
+|------|-------------|
+| `references/cli-commands.md` | All `sf apex run test` command flags, output formats, async execution, and coverage commands |
+| `references/test-patterns.md` | Test class templates — basic, bulk (251+), mock callout, and data factory patterns |
+| `references/testing-best-practices.md` | Core testing principles — AAA pattern, naming conventions, bulk, negative, and mock strategies |
+| `references/test-fix-loop.md` | Agentic test-fix loop implementation and failure analysis decision tree |
+| `references/mocking-patterns.md` | HttpCalloutMock, DML mocking, StubProvider, and selector mocking patterns |
+| `references/performance-optimization.md` | Techniques to reduce test execution time — DML mocking, SOQL mocking, loop optimizations |
+| `assets/basic-test.cls` | Template: standard test class with `@TestSetup`, positive / negative / bulk / edge-case methods |
+| `assets/bulk-test.cls` | Template: bulk test with 251+ records that crosses the 200-record trigger batch boundary |
+| `assets/mock-callout-test.cls` | Template: HTTP callout mock using `HttpCalloutMock` |
+| `assets/test-data-factory.cls` | Template: reusable `TestDataFactory` with create and insert helpers |
+| `assets/dml-mock.cls` | Template: `IDML` interface + `DMLMock` implementation for database-free unit tests |
+| `assets/stub-provider-example.cls` | Template: `StubProvider`-based dependency injection stub |
+| `hooks/scripts/parse-test-results.py` | Post-tool hook — parses `sf apex run test` JSON output and formats failures for the auto-fix loop |
+
+---
+
+## Score Guide
+
+| Score | Meaning |
+|---|---|
+| 108+ | strong production-grade test confidence |
+| 96–107 | good test suite with minor gaps |
+| 84–95 | acceptable but strengthen coverage / assertions |
+| < 84 | below standard; revise before relying on it |