@salesforce/afv-skills 1.8.0 → 1.9.1

package/skills/handling-sf-data/scripts/validate_data_operation.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+sf-data Validation Module
+=========================
+
+Validates data operation files against the 130-point scoring system:
+- Query Efficiency (25 points)
+- Bulk Safety (25 points)
+- Data Integrity (20 points)
+- Security & FLS (20 points)
+- Test Patterns (15 points)
+- Cleanup & Isolation (15 points)
+- Documentation (10 points)
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+class DataOperationValidator:
+    """Validates data operation files."""
+
+    # Scoring categories
+    CATEGORIES = {
+        'query_efficiency': {
+            'name': 'Query Efficiency',
+            'max': 25,
+            'score': 25,
+            'issues': []
+        },
+        'bulk_safety': {
+            'name': 'Bulk Safety',
+            'max': 25,
+            'score': 25,
+            'issues': []
+        },
+        'data_integrity': {
+            'name': 'Data Integrity',
+            'max': 20,
+            'score': 20,
+            'issues': []
+        },
+        'security_fls': {
+            'name': 'Security & FLS',
+            'max': 20,
+            'score': 20,
+            'issues': []
+        },
+        'test_patterns': {
+            'name': 'Test Patterns',
+            'max': 15,
+            'score': 15,
+            'issues': []
+        },
+        'cleanup_isolation': {
+            'name': 'Cleanup & Isolation',
+            'max': 15,
+            'score': 15,
+            'issues': []
+        },
+        'documentation': {
+            'name': 'Documentation',
+            'max': 10,
+            'score': 10,
+            'issues': []
+        }
+    }
+
+    def __init__(self, file_path: str):
+        self.file_path = Path(file_path)
+        self.content = ''
+        self.file_type = ''
+        self.issues: List[Dict[str, Any]] = []
+        self.recommendations: List[str] = []
+        self.categories = self._init_categories()
+
+    def _init_categories(self) -> Dict[str, Dict[str, Any]]:
+        """Initialize fresh category scores."""
+        import copy
+        return copy.deepcopy(self.CATEGORIES)
+
+    def validate(self) -> Optional[Dict[str, Any]]:
+        """Run validation and return results."""
+        if not self.file_path.exists():
+            return None
+
+        try:
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                self.content = f.read()
+        except Exception:
+            return None
+
+        # Determine file type
+        self.file_type = self.file_path.suffix.lower()
+
+        # Run type-specific validation
+        if self.file_type == '.apex':
+            self._validate_apex()
+        elif self.file_type == '.soql':
+            self._validate_soql()
+        elif self.file_type == '.csv':
+            self._validate_csv()
+        elif self.file_type == '.json':
+            self._validate_json()
+        else:
+            return None
+
+        # Calculate total score
+        total_score = sum(cat['score'] for cat in self.categories.values())
+        max_score = sum(cat['max'] for cat in self.categories.values())
+
+        return {
+            'score': total_score,
+            'max_score': max_score,
+            'categories': {cat['name']: {'score': cat['score'], 'max': cat['max']}
+                          for cat in self.categories.values()},
+            'issues': self.issues,
+            'recommendations': self.recommendations
+        }
+
+    def _validate_apex(self):
+        """Validate Apex data operation file."""
+        content = self.content
+
+        # Query Efficiency (25 points)
+        self._check_query_efficiency(content)
+
+        # Bulk Safety (25 points)
+        self._check_bulk_safety(content)
+
+        # Data Integrity (20 points)
+        self._check_data_integrity(content)
+
+        # Security & FLS (20 points)
+        self._check_security(content)
+
+        # Test Patterns (15 points)
+        self._check_test_patterns(content)
+
+        # Cleanup & Isolation (15 points)
+        self._check_cleanup(content)
+
+        # Documentation (10 points)
+        self._check_documentation(content)
+
+    def _validate_soql(self):
+        """Validate SOQL query file."""
+        content = self.content
+
+        # Import SOQL validator
+        try:
+            from soql_validator import SOQLValidator
+            soql_validator = SOQLValidator(content)
+            soql_result = soql_validator.validate()
+
+            # Apply SOQL-specific scoring
+            if soql_result.get('has_where_clause', False):
+                pass  # Good
+            else:
+                self._deduct('query_efficiency', 5, 'Missing WHERE clause')
+
+            if soql_result.get('has_limit', False):
+                pass  # Good
+            else:
+                self._deduct('query_efficiency', 3, 'Missing LIMIT clause')
+
+            if soql_result.get('has_hardcoded_ids', False):
+                self._deduct('query_efficiency', 5, 'Hardcoded record IDs found')
+
+        except ImportError:
+            # Basic SOQL validation
+            if 'WHERE' not in content.upper():
+                self._deduct('query_efficiency', 5, 'Missing WHERE clause')
+            if 'LIMIT' not in content.upper():
+                self._deduct('query_efficiency', 3, 'Missing LIMIT clause')
+
+        # Documentation check for SOQL
+        if not content.strip().startswith('--'):
+            self._deduct('documentation', 5, 'Missing SOQL documentation/comments')
+
+    def _validate_csv(self):
+        """Validate CSV import file."""
+        lines = self.content.strip().split('\n')
+
+        if len(lines) < 2:
+            self._deduct('data_integrity', 10, 'CSV file has no data rows')
+            return
+
+        # Check for header row
+        header = lines[0]
+        if not header or ',' not in header:
+            self._deduct('data_integrity', 5, 'CSV missing proper header row')
+
+        # Check for consistent column count
+        expected_cols = len(header.split(','))
+        for i, line in enumerate(lines[1:], 2):
+            if line.strip() and len(line.split(',')) != expected_cols:
+                self._deduct('data_integrity', 2, f'Inconsistent column count on line {i}')
+                break
+
+        # Check for potential PII patterns
+        self._check_csv_security(self.content)
+
+    def _validate_json(self):
+        """Validate JSON tree import file."""
+        import json as json_lib
+
+        try:
+            data = json_lib.loads(self.content)
+        except json_lib.JSONDecodeError as e:
+            self._deduct('data_integrity', 20, f'Invalid JSON: {str(e)}')
+            return
+
+        # Check for proper sObject tree format
+        if 'records' not in data:
+            self._deduct('data_integrity', 10, 'Missing "records" array')
+            return
+
+        records = data.get('records', [])
+
+        for i, record in enumerate(records):
+            if 'attributes' not in record:
+                self._deduct('data_integrity', 5, f'Record {i+1} missing "attributes"')
+            else:
+                attrs = record['attributes']
+                if 'type' not in attrs:
+                    self._deduct('data_integrity', 3, f'Record {i+1} missing object type')
+                if 'referenceId' not in attrs:
+                    self._deduct('data_integrity', 2, f'Record {i+1} missing referenceId')
+
+    def _check_query_efficiency(self, content: str):
+        """Check for query efficiency issues."""
+        # Check for queries in loops
+        if re.search(r'for\s*\([^)]*\)\s*\{[^}]*\[SELECT', content, re.IGNORECASE | re.DOTALL):
+            self._deduct('query_efficiency', 10, 'SOQL query inside for loop (N+1 pattern)')
+
+        # Check for hardcoded IDs
+        if re.search(r"'[a-zA-Z0-9]{15,18}'", content):
+            self._deduct('query_efficiency', 5, 'Hardcoded Salesforce ID found')
+
+        # Check for SELECT * equivalent (all fields)
+        if re.search(r'SELECT\s+\*', content, re.IGNORECASE):
+            self._deduct('query_efficiency', 5, 'SELECT * is not valid in SOQL')
+
+    def _check_bulk_safety(self, content: str):
+        """Check for bulk safety issues."""
+        # Check for DML in loops
+        dml_in_loop = re.search(
+            r'for\s*\([^)]*\)\s*\{[^}]*(insert|update|delete|upsert)\s+',
+            content, re.IGNORECASE | re.DOTALL
+        )
+        if dml_in_loop:
+            self._deduct('bulk_safety', 10, 'DML operation inside for loop')
+
+        # Check for single-record operations when bulk would be better
+        single_record_pattern = re.search(
+            r'(insert|update|delete)\s+\w+\s*;(?!\s*//\s*single)',
+            content, re.IGNORECASE
+        )
+        # This is a soft check - single records are sometimes intentional
+
+        # Check for list-based DML (good pattern)
+        if re.search(r'(insert|update|delete)\s+\w+List', content, re.IGNORECASE):
+            pass  # Good - using list-based DML
+        elif re.search(r'(insert|update|delete)\s+new\s+List<', content, re.IGNORECASE):
+            pass  # Good - using list
+
+    def _check_data_integrity(self, content: str):
+        """Check for data integrity issues."""
+        # Check for required field handling
+        if 'required' in content.lower() or 'mandatory' in content.lower():
+            pass  # Awareness of required fields
+
+        # Check for null checks
+        if re.search(r'!=\s*null|!= null', content):
+            pass  # Good - null checking
+
+    def _check_security(self, content: str):
+        """Check for security issues."""
+        # Check for PII patterns
+        pii_patterns = [
+            (r'\b\d{3}-\d{2}-\d{4}\b', 'SSN pattern detected'),
+            (r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', 'Credit card pattern detected'),
+            (r'\b[A-Za-z0-9._%+-]+@(gmail|yahoo|hotmail|outlook)\.(com|net|org)\b',
+             'Personal email domain in test data')
+        ]
+
+        for pattern, message in pii_patterns:
+            if re.search(pattern, content):
+                self._deduct('security_fls', 10, message)
+
+        # Check for WITH USER_MODE usage (good practice)
+        if 'WITH USER_MODE' in content.upper():
+            pass  # Good - respecting FLS
+
+    def _check_test_patterns(self, content: str):
+        """Check for good test data patterns."""
+        # Check for bulk record creation (200+)
+        bulk_patterns = [
+            r'(\d{3,})\s*[;,)]',  # Numbers 100+
+            r'count\s*[=:]\s*(\d{3,})',
+            r'recordCount\s*[=:]\s*(\d{3,})'
+        ]
+
+        has_bulk = False
+        for pattern in bulk_patterns:
+            match = re.search(pattern, content)
+            if match:
+                try:
+                    num = int(match.group(1))
+                    if num >= 200:
+                        has_bulk = True
+                except ValueError:
+                    pass
+
+        # Check for edge case handling
+        edge_cases = ['null', 'empty', 'boundary', 'special character', 'unicode']
+        has_edge_cases = any(ec in content.lower() for ec in edge_cases)
+
+        if not has_bulk and 'bulk' not in self.file_path.stem.lower():
+            self._deduct('test_patterns', 5, 'Consider testing with 200+ records for bulkification')
+
+    def _check_cleanup(self, content: str):
+        """Check for cleanup and isolation patterns."""
+        # Check for cleanup provisions
+        cleanup_patterns = ['cleanup', 'delete', 'rollback', 'Savepoint', 'Database.rollback']
+        has_cleanup = any(pattern.lower() in content.lower() for pattern in cleanup_patterns)
+
+        if not has_cleanup:
+            self._deduct('cleanup_isolation', 5, 'No cleanup mechanism found')
+            self.recommendations.append('Add cleanup script or savepoint for test isolation')
+
+        # Check for ID tracking
+        if re.search(r'Set<Id>|List<Id>|createdIds|recordIds', content):
+            pass  # Good - tracking created IDs
+
+    def _check_documentation(self, content: str):
+        """Check for documentation."""
+        # Check for file header comment
+        if not (content.strip().startswith('/*') or
+                content.strip().startswith('//') or
+                content.strip().startswith('/**')):
+            self._deduct('documentation', 3, 'Missing file header documentation')
+
+        # Check for method documentation
+        if re.search(r'/\*\*[\s\S]*?\*/', content):
+            pass  # Has JSDoc-style comments
+        elif re.search(r'//.*description|//.*purpose|//.*usage', content, re.IGNORECASE):
+            pass  # Has inline documentation
+        else:
+            self._deduct('documentation', 2, 'Consider adding method/section documentation')
+
+    def _check_csv_security(self, content: str):
+        """Check CSV content for security issues."""
+        # Check for PII patterns in CSV
+        lines = content.split('\n')
+        for i, line in enumerate(lines, 1):
+            # SSN pattern
+            if re.search(r'\b\d{3}-\d{2}-\d{4}\b', line):
+                self._deduct('security_fls', 10, f'SSN pattern on line {i}')
+                break
+            # Credit card pattern
+            if re.search(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', line):
+                self._deduct('security_fls', 10, f'Credit card pattern on line {i}')
+                break
+
+    def _deduct(self, category: str, points: int, message: str):
+        """Deduct points from a category and record the issue."""
+        if category in self.categories:
+            current = self.categories[category]['score']
+            self.categories[category]['score'] = max(0, current - points)
+            self.categories[category]['issues'].append(message)
+
+        self.issues.append({
+            'category': self.categories.get(category, {}).get('name', category),
+            'severity': 'error' if points >= 10 else 'warning',
+            'message': message,
+            'points': points
+        })

package/skills/harmonizing-datacloud/CREDITS.md

@@ -0,0 +1,3 @@
+# Credits & Acknowledgments
+
+This skill is part of the `*-datacloud` family of skills covering the Data Cloud lifecycle: ingestion, harmonization, segmentation, and retrieval.

package/skills/harmonizing-datacloud/README.md

@@ -0,0 +1,31 @@
+# harmonizing-datacloud
+
+Schema harmonization and unification workflows for Salesforce Data Cloud.
+
+## Use this skill for
+
+- DMOs (Data Model Objects)
+- Field mappings
+- Relationships
+- Identity resolution
+- Unified profiles
+- Data graphs
+- Universal ID lookup
+
+## Example requests
+
+```text
+"Map this DLO to ssot__Individual__dlm"
+"Help me create an identity resolution ruleset"
+"Why are unified profiles not appearing?"
+"Show me the DMO fields before I create mappings"
+```
+
+## Common commands
+
+```bash
+sf data360 dmo list --all -o myorg 2>/dev/null
+sf data360 query describe -o myorg --table ssot__Individual__dlm 2>/dev/null
+sf data360 dmo mapping-list -o myorg --source Contact_Home__dll --target ssot__Individual__dlm 2>/dev/null
+sf data360 identity-resolution list -o myorg 2>/dev/null
+```

package/skills/harmonizing-datacloud/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: harmonizing-datacloud
+description: "Salesforce Data Cloud Harmonize phase. Use this skill when the user works with DMOs, mappings, relationships, identity resolution, unified profiles, data graphs, or universal IDs. TRIGGER when: user works with DMOs, mappings, relationships, identity resolution, unified profiles, data graphs, or universal IDs. DO NOT TRIGGER when: the task is only about streams/DLOs (use preparing-datacloud), segments/insights (use segmenting-datacloud), retrieval/search (use retrieving-datacloud), or STDM/session tracing (use observing-agentforce)."
+license: MIT
+compatibility: "Requires an external community sf data360 CLI plugin and a Data Cloud-enabled org"
+metadata:
+  version: "1.0"
+---
+
+# harmonizing-datacloud: Data Cloud Harmonize Phase
+
+Use this skill when the user needs **schema harmonization and unification work**: DMOs, field mappings, relationships, identity resolution, unified profiles, data graphs, or universal ID lookup.
+
+## When This Skill Owns the Task
+
+Use `harmonizing-datacloud` when the work involves:
+- `sf data360 dmo *`
+- `sf data360 identity-resolution *`
+- `sf data360 data-graph *`
+- `sf data360 profile *`
+- `sf data360 universal-id lookup`
+
+Delegate elsewhere when the user is:
+- still ingesting streams or building DLOs → [preparing-datacloud](../preparing-datacloud/SKILL.md)
+- working on segment logic or calculated insights → [segmenting-datacloud](../segmenting-datacloud/SKILL.md)
+- running SQL, describe, or search-index workflows → [retrieving-datacloud](../retrieving-datacloud/SKILL.md)
+
+---
+
+## Required Context to Gather First
+
+Ask for or infer:
+- source DLO and target DMO names
+- whether the task is schema creation, mapping, IR, or graph-related
+- target org alias
+- whether a ruleset already exists
+- the user’s desired unified entity model
+
+---
+
+## Core Operating Rules
+
+- Inspect DMO schema before creating mappings.
+- Run the shared readiness classifier before mutating harmonization assets: `node ~/.claude/skills/orchestrating-datacloud/scripts/diagnose-org.mjs -o <org> --phase harmonize --json`.
+- Prefer `dmo list --all` when browsing the catalog, but use first-page `dmo list` for fast readiness checks.
+- Use `query describe` or `dmo get --json` instead of inventing unsupported describe flows.
+- Treat identity resolution runs as asynchronous and verify results after execution.
+- Keep unified-profile work separate from STDM/session tracing work.
+
+---
+
+## Recommended Workflow
+
+### 1. Classify readiness for harmonize work
+```bash
+node ~/.claude/skills/orchestrating-datacloud/scripts/diagnose-org.mjs -o <org> --phase harmonize --json
+```
+
+### 2. Inspect the catalog
+```bash
+sf data360 dmo list --all -o <org> 2>/dev/null
+sf data360 identity-resolution list -o <org> 2>/dev/null
+```
+
+### 3. Inspect schema before mapping
+```bash
+sf data360 query describe -o <org> --table ssot__Individual__dlm 2>/dev/null
+sf data360 dmo get -o <org> --name ssot__Individual__dlm --json 2>/dev/null
+```
+
+### 4. Create or review mappings intentionally
+```bash
+sf data360 dmo mapping-list -o <org> --source Contact_Home__dll --target ssot__Individual__dlm 2>/dev/null
+sf data360 dmo map-to-canonical -o <org> --dlo Contact_Home__dll --dmo ssot__Individual__dlm --dry-run 2>/dev/null
+```
+
+### 5. Run IR only after mappings are trustworthy
+```bash
+sf data360 identity-resolution create -o <org> -f ir-ruleset.json 2>/dev/null
+sf data360 identity-resolution run -o <org> --name Main 2>/dev/null
+```
+
+---
+
+## High-Signal Gotchas
+
+- `dmo list` should usually use `--all`.
+- Use `query describe` or `dmo get --json`; there is no `dmo describe` command.
+- Mapping and related commands can be sensitive to API-version differences.
+- Unified DMO names are ruleset-specific rather than generic.
+- Data graph definitions are sensitive to field selection and relationship shape.
+- If `dmo list` works but `identity-resolution list` is gated, treat that as a phase-specific gap rather than a full Data Cloud outage.
+
+---
+
+## Output Format
+
+```text
+Harmonize task: <dmo / mapping / relationship / ir / data-graph>
+Source/target: <dlo → dmo or ruleset/graph names>
+Target org: <alias>
+Artifacts: <json files / commands>
+Verification: <passed / partial / blocked>
+Next step: <segment / retrieve / follow-up>
+```
+
+---
+
+## References
+
+- [README.md](README.md)
+- [../orchestrating-datacloud/assets/definitions/dmo.template.json](../orchestrating-datacloud/assets/definitions/dmo.template.json)
+- [../orchestrating-datacloud/assets/definitions/mapping.template.json](../orchestrating-datacloud/assets/definitions/mapping.template.json)
+- [../orchestrating-datacloud/assets/definitions/relationship.template.json](../orchestrating-datacloud/assets/definitions/relationship.template.json)
+- [../orchestrating-datacloud/assets/definitions/identity-resolution.template.json](../orchestrating-datacloud/assets/definitions/identity-resolution.template.json)
+- [../orchestrating-datacloud/assets/definitions/data-graph.template.json](../orchestrating-datacloud/assets/definitions/data-graph.template.json)
+- [../orchestrating-datacloud/references/feature-readiness.md](../orchestrating-datacloud/references/feature-readiness.md)

package/skills/modeling-omnistudio-epc-catalog/CREDITS.md

@@ -0,0 +1,14 @@
+# Credits & Acknowledgments
+
+This skill was created from practical Salesforce Industries CME EPC implementation patterns and DataPack examples in this repository.
+
+## Repository Example Sources
+
+The example packs in this skill are curated, reusable sample payloads for documentation and template authoring.
+
+- `assets/` (canonical EPC bundle template set)
+- `assets/examples/samsung-galaxy-s22-bundle/` (bundle offer example)
+- `assets/examples/business-internet-premium-fttc-simple-offer/` (simple offer example)
+- `assets/examples/business-internet-pro-vpl-simple-offer/` (simple offer example)
+- `assets/examples/static-ip-simple-offer/` (simple offer example)
+- `examples/business-internet-plus-bundle/` (generated example with transcript)

package/skills/modeling-omnistudio-epc-catalog/README.md

@@ -0,0 +1,89 @@
+# modeling-omnistudio-epc-catalog
+
+Salesforce Industries CME EPC product-modeling skill for Product2-based catalog design. Build offer bundles, attributes, Product Child Items, and companion DataPack JSON artifacts with a 120-point quality rubric.
+
+## Features
+
+- **Offer Bundle Modeling**: Create `Product2` offers with `SpecificationType=Offer` and `SpecificationSubType=Bundle`
+- **Attribute Modeling**: Define attribute metadata, defaults, valid values, and assignment payloads
+- **Bundle Composition**: Build root and child `%vlocity_namespace%__ProductChildItem__c` rows with quantity semantics
+- **Companion DataPack Generation**: Produce pricing, orchestration, decomposition, override, and parent-key files
+- **DataPack Integrity Controls**: Keep global keys, source keys, and lookup references consistent
+- **120-Point Scoring**: Validate bundle quality across 6 EPC-focused categories
+
+## Quick Start
+
+### 1. Invoke the skill
+
+```
+Skill: modeling-omnistudio-epc-catalog
+Request: "Create a Product2 offer bundle named Business Internet Plus with ProductCode BIZ-INT-PLUS-01, 3 child products, and generate all companion DataPack JSON files from the assets templates."
+```
+
+### 2. Typical operations
+
+| Operation | Example Request |
+|-----------|-----------------|
+| Create bundle | "Create a Product2 offer bundle for Business Fiber Pro with 3 child products and full companion metadata." |
+| Add attributes | "Add Contract Term and Download Speed attributes with defaults and valid values." |
+| Build child items | "Create root and child ProductChildItem records with min/max/default quantity rules." |
+| Generate companions | "Generate pricebook, price list, object field attribute, orchestration, decomposition, override, and parent key files." |
+| Review and score | "Review this bundle DataPack and score it with the 120-point rubric." |
+
+## Companion Files for Full Bundle Payload
+
+When generating a complete bundle, include:
+
+- `*_DataPack.json`
+- `*_AttributeAssignments.json`
+- `*_ProductChildItems.json`
+- `*_PricebookEntries.json`
+- `*_PriceListEntries.json`
+- `*_ObjectFieldAttributes.json`
+- `*_OrchestrationScenarios.json`
+- `*_DecompositionRelationships.json`
+- `*_CompiledAttributeOverrides.json`
+- `*_OverrideDefinitions.json`
+- `*_ParentKeys.json`
+
+## Bundled Examples
+
+- [assets/](assets/) - canonical EPC bundle template set for DataPack authoring
+- [assets/examples/](assets/examples/) - additional bundle and simple-offer sample packs
+- [examples/business-internet-plus-bundle/](examples/business-internet-plus-bundle/) - generated Business Internet Plus example with transcript
+
+## Scoring System (120 Points)
+
+| Category | Points | Focus |
+|----------|--------|-------|
+| Catalog Identity and Naming | 20 | Product naming, ProductCode quality, stable key strategy |
+| EPC Product Structure | 20 | Required Product2/EPC fields, lifecycle and activation coherence |
+| Attribute Modeling | 25 | Category quality, valid values/defaults, required/display behavior |
+| Offer Bundle Composition | 25 | Root PCI, child integrity, quantity semantics |
+| DataPack Integrity | 15 | Namespace placeholder usage, lookup portability, key consistency |
+| Documentation and Handoff | 15 | Intent clarity, risks, verification guidance |
+
+**Thresholds**: `>=95` Deploy-ready | `70-94` Needs review | `<70` Block and fix
+
+## Cross-Skill Integration
+
+| Related Skill | When to Use |
+|---------------|-------------|
+| analyzing-omnistudio-dependencies | Inventory namespace and dependencies before modeling |
+| building-omnistudio-omniscript | Build guided selling UX on top of modeled catalog |
+| building-omnistudio-integration-procedure | Orchestrate product and pricing interactions server-side |
+| building-omnistudio-callable-apex | Implement callable Apex actions used by OmniStudio/IP flows over EPC selections |
+| deploying-metadata | Validate and deploy generated metadata artifacts |
+
+## Documentation
+
+- [SKILL.md](SKILL.md) - Full EPC workflow, guardrails, and scoring
+- [references/epc-field-guide.md](references/epc-field-guide.md) - EPC field-level guidance
+- [references/naming-conventions.md](references/naming-conventions.md) - Naming and keying conventions
+- [../building-omnistudio-callable-apex/README.md](../building-omnistudio-callable-apex/README.md) - Companion callable Apex patterns
+
+## Requirements
+
+- Salesforce Industries org with EPC enabled
+- sf CLI v2 (for validation/deploy workflows)
+- Compatible namespace model (`%vlocity_namespace%`, `vlocity_cmt`, or Core)