sf-industry-cme-epc-model: CME EPC Product and Offer Modeling

Expert Salesforce Industries CME EPC modeler for creating Product2-based catalog entries, assigning configurable attributes, and building offer bundles through Product Child Item relationships.

This skill is optimized for DataPack-style metadata authoring. Use the canonical template set in

assets/

```
assets/product2-offer-template.json
```

assets/attribute-assignment-template.json

```
assets/product-child-item-template.json
```
```
assets/pricebook-entries-template.json
```
```
assets/price-list-entries-template.json
```

assets/object-field-attributes-template.json

assets/orchestration-scenarios-template.json

assets/decomposition-relationships-template.json

assets/compiled-attribute-overrides-template.json

assets/override-definitions-template.json

```
assets/parent-keys-template.json
```

Additional packaged examples are available under

assets/examples/

with one folder per bundle/simple-offer sample. The root

assets/

folder contains the canonical baseline template set for bundle authoring.

Quick Reference

Primary object:
```
Product2
```
(EPC product and offer records)

Attribute data:

%vlocity_namespace%__AttributeMetadata__c

%vlocity_namespace%__AttributeDefaultValues__c

, and

%vlocity_namespace%__AttributeAssignment__c

Offer bundle composition:

%vlocity_namespace%__ProductChildItem__c

Offer marker:

%vlocity_namespace%__SpecificationType__c = "Offer"

and

%vlocity_namespace%__SpecificationSubType__c = "Bundle"

Companion bundle artifacts: pricebook entries, price list entries, object field attributes, orchestration scenarios, decomposition relationships, compiled attribute overrides, override definitions, and parent keys

Scoring: 120 points across 6 categories.
Thresholds:

>= 95

Deploy-ready |

70-94

Needs review |

< 70

Block and fix.

Asset Template Set

Use the root

assets/

templates when creating a bundle payload:

```
product2-offer-template.json
```
```
attribute-assignment-template.json
```
```
product-child-item-template.json
```
```
pricebook-entries-template.json
```
```
price-list-entries-template.json
```
```
object-field-attributes-template.json
```
```
orchestration-scenarios-template.json
```

decomposition-relationships-template.json

compiled-attribute-overrides-template.json

```
override-definitions-template.json
```
```
parent-keys-template.json
```

For additional real-world variants, use the per-example folders under

assets/examples/

Core Responsibilities

Product Creation: Create EPC Product2 records with consistent naming, lifecycle dates, status, and classification fields.
Attribute Modeling: Define category-based attributes, defaults, valid value sets, display sequences, and required flags.
Offer Bundle Modeling: Compose offers with child products using
```
%vlocity_namespace%__ProductChildItem__c
```
records and clear quantity rules.
Companion Metadata Generation: Generate and align all related bundle files (pricing, object field attributes, orchestration/decomposition, overrides, parent keys) from the same offer baseline.
DataPack Consistency: Keep record source keys, global keys, lookup objects, and namespace fields internally consistent for deployment.

Invocation Rules (Mandatory)

Route to this skill whenever the prompt intent matches either of these:

Create a product bundle:
- User asks to create/build/generate/model an EPC offer bundle.
- User asks for Product2 offer setup with Product Child Items.
- User asks to generate bundle DataPack JSON artifacts from templates/examples.
Score or review an existing product bundle:
- User asks to score/assess/validate/audit an existing EPC bundle.
- User asks to apply the 120-point rubric to existing Product2/PCI/attribute payloads.
- User asks for risk findings, quality gaps, or fix recommendations on bundle metadata.

Instruction priority: treat these two intents as direct triggers for

sf-industry-cme-epc-model

, even if the prompt is brief and does not mention EPC by name.

Workflow (Create/Review)

Phase 1: Identify Catalog Intent

Ask for:

Product type: spec product or offer bundle
Domain taxonomy: Family, Type/SubType, category path, and channel
Attribute requirements: required/optional, picklist values, default values
Bundle composition: child products, quantity constraints, optional vs required
Target org namespace model:
```
%vlocity_namespace%
```
,
```
vlocity_cmt
```
, or Core

Phase 1A: Clarifying Questions for Complete Bundle (Mandatory)

Before generating a new offer bundle payload, ask clarifying questions until all required inputs are known.

Required clarification checklist:

Offer identity
- What is the offer name and
```
ProductCode
```
  ?
- Is this net-new or an update to an existing Product2 offer?
Catalog classification
- What are Family, Type/SubType, and channel/sales context values?
- Should
```
SpecificationType=Offer
```
  and
```
SpecificationSubType=Bundle
```
  be set now?

Lifecycle and availability

What are
```
EffectiveDate
```
and
```
SellingStartDate
```
?

Should

IsActive

and

%vlocity_namespace%__IsOrderable__c

be true at creation time?

Child product composition
- Which child products are included (name/code for each)?
- For each child, what are required/optional semantics and sequence order?
Quantity behavior per child
- What are
```
MinQuantity
```
  ,
```
MaxQuantity
```
  , and default
```
Quantity
```
  ?
- Should
```
%vlocity_namespace%__MinMaxDefaultQty__c
```
  be enforced for each line?
Attribute model
- Which attributes are required vs optional?
- What are valid values, defaults, display types, and display sequences?
Pricing and companion artifacts
- Should pricebook and price list entries be generated now?
- Should orchestration/decomposition/override/parent-key files be included in the same request?
Namespace and keying
- Which namespace convention should be used (
```
%vlocity_namespace%
```
  ,
```
vlocity_cmt
```
  , or Core)?
- Are there existing global keys/source keys to preserve?

If any required checklist item is unanswered, do not generate final bundle files yet; ask focused follow-up questions first.

Phase 2: Build Product2 Backbone

For every new EPC record, define:

```
Name
```
```
ProductCode
```
(unique, stable, environment-agnostic)
```
%vlocity_namespace%__GlobalKey__c
```
(stable UUID-style key)

%vlocity_namespace%__SpecificationType__c

and

%vlocity_namespace%__SpecificationSubType__c

%vlocity_namespace%__Status__c

and date fields (

EffectiveDate

SellingStartDate

)

IsActive

and

%vlocity_namespace%__IsOrderable__c

Use

assets/product2-offer-template.json

as baseline structure.

Phase 3: Add Attributes

When attributes are required:

Populate

%vlocity_namespace%__AttributeMetadata__c

category and

productAttributes

records.

Populate
```
%vlocity_namespace%__AttributeDefaultValues__c
```
with attribute code to default value mapping.
Create
```
%vlocity_namespace%__AttributeAssignment__c
```
records with:
- category linkage
- attribute linkage
- UI display type (dropdown, etc.)
- valid values and default marker

Use

assets/attribute-assignment-template.json

as the assignment baseline.

Phase 4: Build Offer Bundles

For offers:

Keep parent

Product2

record as offer (

SpecificationType=Offer

SpecificationSubType=Bundle

Create root

%vlocity_namespace%__ProductChildItem__c

row (

IsRootProductChildItem=true

Add child rows per component with:
- parent and child references
- sequence and line number
- min/max/default quantity behavior (
```
MinMaxDefaultQty
```
  ,
```
MinQuantity
```
  ,
```
MaxQuantity
```
  ,
```
Quantity
```
  )
Use override rows only when behavior differs from inherited/default behavior.

Use

assets/product-child-item-template.json

for child relationship structure.

For complete bundle payloads, also align and include:

```
assets/pricebook-entries-template.json
```
```
assets/price-list-entries-template.json
```

assets/object-field-attributes-template.json

assets/orchestration-scenarios-template.json

assets/decomposition-relationships-template.json

assets/compiled-attribute-overrides-template.json

assets/override-definitions-template.json

```
assets/parent-keys-template.json
```

Phase 4B: Generate Companion Metadata Files

When the user asks to generate a bundle, generate/update all companion files together as one coherent set:

```
pricebook-entries-template.json
```
and
```
price-list-entries-template.json
```
- Keep Product2 GlobalKey/ProductCode references aligned with the parent offer.
```
object-field-attributes-template.json
```
- Keep object class references and field mappings aligned with the same offer model.
```
orchestration-scenarios-template.json
```
and
```
decomposition-relationships-template.json
```
- Keep decomposition and orchestration artifacts consistent with bundle child items.
```
compiled-attribute-overrides-template.json
```
and
```
override-definitions-template.json
```
- Keep override keys and references aligned with attribute metadata and assignments.
```
parent-keys-template.json
```
- Keep parent linkage values synchronized with generated artifact keys.

Mandatory rule: do not generate only a partial subset when a full bundle payload is requested unless the user explicitly asks for a limited file scope.

Phase 5: Validate and Handoff

Provide a completion block:

text

EPC Model Complete: <Name>
Type: <Spec Product|Offer Bundle>
ProductCode: <code>
Attributes: <count>
Bundle Children: <count>
Companion Metadata Files: <count generated>
Validation Score: <score>/120
Risks: <none|list>

Generation Guardrails (Mandatory)

If any anti-pattern appears, stop and ask for confirmation before proceeding.

Anti-pattern	Why it fails	Required correction
Missing `ProductCode` or unstable code values	Breaks quote/cart references and package diffs	Use deterministic code convention
Hardcoded org-specific IDs in relationships	Fails across orgs/environments	Use lookup objects with matching keys/global keys
Offer bundle without root PCI row	Runtime bundle traversal issues	Add root `%vlocity_namespace%__ProductChildItem__c`
Attribute defaults not present in valid values	Invalid cart configuration defaults	Ensure default exists in allowed value set
Duplicate display sequences in same attribute category	UI ordering conflict	Enforce unique and spaced sequence values
Offer marked active with incomplete child references	Broken bundle at runtime	Complete and validate child link set before activation
Mixed naming styles ( `snake_case` , ad hoc abbreviations)	Reduces maintainability and discoverability	Enforce naming convention from references doc

Scoring Model (120 Points)

1) Catalog Identity and Naming (20)

Product name clarity and uniqueness
```
ProductCode
```
convention quality
Type/SubType/Family coherence
Stable keying (
```
GlobalKey
```
, source key integrity)

2) EPC Product Structure (20)

Required Product2 + EPC fields present
Lifecycle dates and status alignment
Orderable/active flags are coherent
Record type and classification consistency

3) Attribute Modeling (25)

Category and attribute grouping quality
Valid values + default alignment
Required/read-only/filterable semantics
Display sequence and UX consistency

4) Offer Bundle Composition (25)

Root PCI presence and correctness
Child references and sequencing integrity
Quantity constraints correctness
Optional/required semantics reflected in min/max/defaults

5) DataPack Integrity (15)

Namespace placeholder correctness
Lookup object key integrity
No environment-specific brittle fields

6) Documentation and Handoff (15)

Clear explanation of modeled intent
Testing checklist included
Risks and assumptions explicitly called out

CLI and Validation Commands

bash

# Query candidate EPC products
sf data query -q "SELECT Id,Name,ProductCode,Family,IsActive FROM Product2 ORDER BY LastModifiedDate DESC" -o <org>

# Query Product Child Items for an offer
sf data query -q "SELECT Id,Name,%vlocity_namespace%__ParentProductName__c,%vlocity_namespace%__ChildProductName__c,%vlocity_namespace%__MinMaxDefaultQty__c FROM %vlocity_namespace%__ProductChildItem__c WHERE %vlocity_namespace%__ParentProductName__c='<Offer Name>'" -o <org>

# Retrieve Product2 metadata package members (as applicable to project format)
sf project retrieve start -m Product2:<DeveloperNameOrName> -o <org>

# Validate deployment in dry-run mode
sf project deploy start -x manifest/package.xml --dry-run -o <org>

Sample Skill Invocation Commands

Use these examples to invoke this skill from your agent/CLI workflow: