@salesforce/afv-skills 1.5.0 → 1.5.2

package/skills/building-ui-bundle-app/SKILL.md

@@ -0,0 +1,325 @@
+---
+name: building-ui-bundle-app
+description: "Build complete Salesforce React UI bundle applications from natural language descriptions. Use this skill when a user requests a full React app, UI bundle app, web app on Salesforce, or describes a scenario requiring scaffolding, features, data access, UI pages, and deployment of a React application hosted on Salesforce. Orchestrates all UI bundle skills in proper dependency order to produce a deployable application. Triggers on: build a React app, create a UI bundle, build me an app, full-stack Salesforce React app, create a web app on Salesforce."
+metadata:
+  version: "1.0"
+  related-skills: generating-ui-bundle-metadata, generating-ui-bundle-features, using-ui-bundle-salesforce-data, building-ui-bundle-frontend, implementing-ui-bundle-agentforce-conversation-client, implementing-ui-bundle-file-upload, deploying-ui-bundle, generating-experience-react-site
+---
+
+# Building a UI Bundle App
+
+## Overview
+
+Build a complete, deployable Salesforce React UI bundle application from a natural language description by orchestrating specialized UI bundle skills in correct dependency order. Each skill **MUST** be explicitly loaded before executing its phase.
+
+## When to Use This Skill
+
+**Use when:**
+
+- User requests a "React app", "UI bundle", "web app", or "full-stack app" on Salesforce
+- User says "build an app", "create an application" and the context implies a non-LWC based frontend (e.g. React)
+- The work produces a complete UI bundle with scaffolding, features, data access, and UI -- not a single component in isolation
+
+**Examples that should trigger this skill:**
+
+- "Build a React app for managing customer cases with Salesforce data"
+- "Create a UI bundle for an employee directory with search and navigation"
+- "I need a full-stack React app with authentication, data tables, and file uploads"
+- "Build a coffee shop ordering app on Salesforce"
+
+**Do NOT use when:**
+
+- Creating a single page or component (use `building-ui-bundle-frontend`)
+- Only installing a feature (use `generating-ui-bundle-features`)
+- Only setting up data access (use `using-ui-bundle-salesforce-data`)
+- Only deploying an existing app (use `deploying-ui-bundle`)
+- Building a Lightning Experience app with custom objects and metadata (use `generating-lightning-app`)
+- Troubleshooting or debugging an existing UI bundle
+
+---
+
+## Dependency Graph & Build Order
+
+### Phase 1: Scaffolding (Foundation)
+
+```
+UI Bundle scaffold (sf ui-bundle generate)
+    v
+Install dependencies (npm install)
+    v
+Bundle metadata (uibundle-meta.xml, ui-bundle.json)
+    v
+CSP Trusted Sites (if external domains needed)
+```
+
+Creates the UI bundle directory structure, meta XML, and optional routing/headers config. All subsequent phases require the scaffold to exist.
+
+### Phase 2: Features (Optional)
+
+```
+Search project code (src/) for existing implementations
+    v
+Install dependencies (npm install)
+    v
+Search, describe, and install features (auth, shadcn, search, navigation, GraphQL)
+    v
+Resolve conflicts (two-pass: --on-conflict error, then --conflict-resolution)
+    v
+Integrate __example__ files into target files, then delete them
+```
+
+Installs pre-built, tested feature packages. Skip if the app requires no pre-built features. Always check for an existing feature before building from scratch. Features provide the foundation that UI components build on top of.
+
+### Phase 3: Data Access (Backend Wiring)
+
+```
+Acquire schema (npm run graphql:schema)
+    v
+Look up entity schema (graphql-search.sh, max 2 runs)
+    v
+Generate queries/mutations (use verified field names, @optional on all record fields)
+    v
+Validate and test (npx eslint, ask user before testing mutations)
+```
+
+Sets up the data layer using `@salesforce/sdk-data`. GraphQL is preferred for record operations; REST for Connect, Apex, or UI API endpoints.
+
+### Phase 4: UI (Frontend)
+
+```
+Layout, navigation, header, and footer (appLayout.tsx)
+    v
+Pages (routed views)
+    v
+Components (widgets, forms, tables)
+```
+
+Builds the React UI. References the data layer from Phase 3 and the features from Phase 2. Must replace all boilerplate and placeholder content.
+
+### Phase 5: Integrations (Optional)
+
+```
+Agentforce chat widget (if requested)
+File upload API (if requested)
+```
+
+These are independent and can be executed in parallel if both are needed.
+
+### Phase 6: Deployment
+
+```
+Org authentication
+    v
+Pre-deploy UI bundle build (npm install + npm run build)
+    v
+Deploy metadata
+    v
+Post-deploy configuration (permissions, profiles, named credentials, connected apps, custom settings, flow activation)
+    v
+Import data (if data plan exists)
+    v
+Fetch GraphQL schema and run codegen
+*(Re-fetches schema from the deployed org -- required because the remote schema may differ from the local one used in Phase 3)*
+    v
+Final UI bundle build (rebuilds with the deployed schema)
+```
+
+Follows the canonical 7-step deployment sequence. Must deploy metadata before fetching schema. Must assign permissions before schema fetch.
+
+### Phase 7: Experience Site (Optional)
+
+```
+Resolve site properties (siteName, appDevName, etc.)
+    v
+Generate site metadata (Network, CustomSite, DigitalExperience)
+    v
+Deploy site infrastructure
+```
+
+Creates the Digital Experience site that hosts the UI bundle. Only needed when the user wants a public-facing or authenticated site URL.
+
+---
+
+## Execution Workflow
+
+### STEP 1: Requirements Analysis & Planning
+
+**Actions:**
+
+1. Parse the user's natural language request
+2. Identify the app name and purpose
+3. Extract pages and navigation structure
+4. Identify data entities and Salesforce objects needed
+5. Detect feature requirements (authentication, search, file upload, chat)
+6. Determine if an Experience Site is needed
+7. Identify external domains for CSP registration
+
+**Output: Build Plan**
+
+```
+UI Bundle App Build Plan: [App Name]
+
+SCAFFOLDING:
+- App name: [PascalCase name]
+- Routing: [SPA rewrites, trailing slash config]
+- External domains: [domains needing CSP registration]
+
+FEATURES:
+- [list of features to install: auth, shadcn, search, navigation, etc.]
+
+DATA ACCESS:
+- Objects: [Salesforce objects to query/mutate]
+- Queries: [list of GraphQL queries needed]
+- REST endpoints: [Apex REST or Connect API calls, if any]
+
+UI:
+- Layout: [description of app shell/navigation]
+- Pages: [list of pages with routes]
+- Components: [key components per page]
+- Design direction: [aesthetic/style intent]
+
+INTEGRATIONS (if applicable):
+- Agentforce chat: [yes/no, agent ID if known]
+- File upload: [yes/no, record linking pattern]
+
+DEPLOYMENT:
+- Target org: [org alias if known]
+- Experience Site: [yes/no, site name if applicable]
+
+SKILL LOAD ORDER:
+1. generating-ui-bundle-metadata
+2. generating-ui-bundle-features (if features needed)
+3. using-ui-bundle-salesforce-data (if data access needed)
+4. building-ui-bundle-frontend
+5a. implementing-ui-bundle-agentforce-conversation-client (if chat requested)
+5b. implementing-ui-bundle-file-upload (if file upload requested)
+6. deploying-ui-bundle
+7. generating-experience-react-site (if site requested)
+```
+
+### STEP 2: Per-Phase Execution
+
+Execute each phase sequentially. Complete all steps within a phase before moving to the next. For each phase:
+
+| Step | What to do | Why |
+|------|-----------|-----|
+| **1. Load skill** | Invoke the skill (e.g., via the Skill tool) for this phase | Gives you the current rules, patterns, constraints, and implementation guides |
+| **2. Execute** | Follow the loaded skill's workflow to generate code/config | The skill defines HOW to do the work correctly |
+| **3. Verify** | Run lint and build from the UI bundle directory | Catch errors before moving to the next phase |
+| **4. Checkpoint** | Confirm phase completion before proceeding | Ensures dependencies are satisfied for the next phase |
+
+**Do NOT skip step 1 (loading the skill).** Even if you remember the skill's content, skills evolve. Always load the current version.
+
+---
+
+**Phase 1 -- Scaffolding**
+- 1. Load skill: Invoke `generating-ui-bundle-metadata`
+- 2. Execute: Run `sf ui-bundle generate`, install dependencies (`npm install`), configure meta XML, ui-bundle.json, and CSP trusted sites
+- 3. Verify: Confirm directory structure and metadata files exist
+- 4. Checkpoint: UI bundle scaffold is ready -- proceed to Phase 2
+
+**Phase 2 -- Features** (skip if no pre-built features needed)
+- 1. Load skill: Invoke `generating-ui-bundle-features`
+- 2. Execute: Install dependencies, search and install features, integrate example files
+- 3. Verify: Run `npm run build` to confirm features integrate cleanly
+- 4. Checkpoint: Features installed -- proceed to Phase 3
+
+**Phase 3 -- Data Access** (skip if no Salesforce data needed)
+- 1. Load skill: Invoke `using-ui-bundle-salesforce-data`
+- 2. Execute: Fetch schema, look up entities, generate queries/mutations, wire into components
+- 3. Verify: Run `npx eslint` on files with GraphQL queries
+- 4. Checkpoint: Data layer ready -- proceed to Phase 4
+
+**Phase 4 -- UI**
+- 1. Load skill: Invoke `building-ui-bundle-frontend`
+- 2. Execute: Build layout, pages, components, navigation. Replace all boilerplate.
+- 3. Verify: Run lint and build -- 0 errors required
+- 4. Checkpoint: UI complete -- proceed to Phase 5
+
+**Phase 5 -- Integrations** (skip if not requested)
+- 1. Load skill(s): Invoke `implementing-ui-bundle-agentforce-conversation-client` (5a) and/or `implementing-ui-bundle-file-upload` (5b). If both are needed, they are independent and can be executed in parallel.
+- 2. Execute: Follow each skill's workflow to add the integration
+- 3. Verify: Run lint and build
+- 4. Checkpoint: Integrations complete -- proceed to Phase 6
+
+**Phase 6 -- Deployment**
+- 1. Load skill: Invoke `deploying-ui-bundle`
+- 2. Execute: Follow the 7-step deployment sequence (auth, build, deploy, permissions, data, schema, final build)
+- 3. Verify: Confirm deployment succeeds and app is accessible
+- 4. Checkpoint: App deployed -- proceed to Phase 7 if needed
+
+**Phase 7 -- Experience Site** (skip if not requested)
+- 1. Load skill: Invoke `generating-experience-react-site`
+- 2. Execute: Resolve properties, generate site metadata, deploy
+- 3. Verify: Confirm site URL is accessible
+- 4. Checkpoint: Site live -- build complete
+
+### STEP 3: Final Summary
+
+After all phases complete, present a build summary:
+
+```
+UI Bundle App Build Complete: [App Name]
+
+PHASES COMPLETED:
+[x] Phase 1: Scaffolding -- [app name] UI bundle created
+[x] Phase 2: Features -- [list of features installed, or "skipped"]
+[x] Phase 3: Data Access -- [list of entities wired up]
+[x] Phase 4: UI -- [count] pages, [count] components
+[x] Phase 5: Integrations -- [list or "none"]
+[x] Phase 6: Deployment -- deployed to [org]
+[x] Phase 7: Experience Site -- [site URL or "skipped"]
+
+FILES GENERATED:
+[list key files and their paths]
+
+NEXT STEPS:
+[any manual steps the user should take]
+```
+
+---
+
+## Validation
+
+Before presenting the build as complete, verify:
+
+- [ ] **Scaffold exists**: UI bundle directory with valid meta XML and ui-bundle.json
+- [ ] **Dependencies installed**: `node_modules/` exists and `package.json` has expected packages
+- [ ] **Build passes**: `npm run build` produces `dist/` with no errors
+- [ ] **Lint passes**: `npx eslint src/` reports 0 errors
+- [ ] **No boilerplate**: All placeholder text, default titles, and template content has been replaced
+- [ ] **Navigation works**: `appLayout.tsx` has real nav items matching created pages
+- [ ] **Data layer wired**: Components use `@salesforce/sdk-data` (if data access phase was executed)
+- [ ] **CSP registered**: All external domains have CSP Trusted Site metadata (if applicable)
+
+---
+
+## Error Handling
+
+### Category 1: Stop and Ask User
+
+- App purpose is too vague to determine pages or data needs
+- User wants features that conflict (e.g., "no authentication" + "show user-specific data")
+- Target org is unknown and deployment is requested
+
+### Category 2: Log Warning, Continue
+
+- A feature install has minor conflicts (resolve and continue)
+- Optional integration setup encounters non-blocking issues
+- Build has non-error warnings
+
+---
+
+## Best Practices
+
+### 1. Always Follow Phase Order
+
+Never build UI before installing features. Never deploy before building. Dependencies are strict.
+
+### 2. Replace All Boilerplate
+
+Every generated app must feel purpose-built. Replace "React App" titles, "Vite + React" placeholders, and all default content with real app-specific text and branding.
+
+### 3. Design with Intent
+
+Follow the design thinking and frontend aesthetics guidance from `building-ui-bundle-frontend`. Every app should have a clear visual direction -- not generic defaults.

package/skills/building-ui-bundle-frontend/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: building-ui-bundle-frontend
+description: "Build and modify React UI for Salesforce UI bundles — pages, components, layout, navigation, and headers/footers. Use whenever creating or editing TSX/JSX files or making visual/layout changes. Triggers on: add page, add component, header, footer, navigation, layout, styling, Tailwind, shadcn, React component, appLayout."
+---
+
+# UI Bundle UI
+
+## Identify the Task
+
+Determine which category the request falls into:
+
+| Category | Examples | Implementation Guide |
+|----------|----------|---------------------|
+| **Page** | New routed page (contacts, dashboard, settings) | `implementation/page.md` |
+| **Header / Footer** | Site-wide nav bar, footer, branding | `implementation/header-footer.md` |
+| **Component** | Widget, card, table, form, dialog | `implementation/component.md` |
+
+---
+
+## Layout and Navigation
+
+`appLayout.tsx` is the source of truth for navigation and layout. Every page shares this shell.
+
+When making any change that affects navigation, header, footer, sidebar, theme, or layout:
+
+1. Edit `src/appLayout.tsx` — the layout used by `routes.tsx`
+2. Replace all default/template nav items and labels with app-specific links and names
+3. Replace placeholder app name everywhere: header, nav brand, footer, `<title>` in `index.html`
+
+Before finishing, confirm: Did I update `appLayout.tsx` with real nav items and branding?
+
+| What | Where |
+|------|-------|
+| Layout, nav, branding | `src/appLayout.tsx` |
+| Document title | `index.html` |
+| Root page content | Component at root route in `routes.tsx` |
+
+---
+
+## React and TypeScript Standards
+
+### Routing
+
+Use a single router package. With `createBrowserRouter` / `RouterProvider`, all imports must come from `react-router` (not `react-router-dom`).
+
+### Component Library and Styling
+
+- **shadcn/ui** for components: `import { Button } from '@/components/ui/button';`
+- **Tailwind CSS** utility classes
+
+### URL and Path Handling
+
+Apps run behind dynamic base paths. Router navigation (`<Link to>`, `navigate()`) uses absolute paths (`/x`). Non-router attributes (`<img src>`) use dot-relative (`./x`). Prefer Vite `import` for static assets.
+
+### TypeScript
+
+- Never use `any` — use proper types, generics, or `unknown` with type guards
+- Event handlers: `(event: React.FormEvent<HTMLFormElement>): void`
+- State: `useState<User | null>(null)` — always provide the type parameter
+- No unsafe assertions (`obj as User`) — use type guards instead
+
+### Module Restrictions
+
+React UI bundles must not import Salesforce platform modules like `lightning/*` or `@wire` (LWC-only). For data access, use the `using-ui-bundle-salesforce-data` skill.
+
+---
+
+## Design Thinking
+
+Before coding, commit to a bold aesthetic direction:
+
+- **Purpose:** What problem does this interface solve? Who uses it?
+- **Tone:** Pick a clear direction — brutally minimal, maximalist, retro-futuristic, organic, luxury, playful, editorial, brutalist, art deco, soft/pastel, industrial. Use these as inspiration but design one true to the context.
+- **Differentiation:** What makes this unforgettable? What's the one thing someone will remember?
+
+Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work — the key is intentionality, not intensity.
+
+---
+
+## Frontend Aesthetics
+
+- **Typography:** Choose distinctive, characterful fonts. Pair a display font with a refined body font. Never default to Inter, Roboto, Arial, Space Grotesk, or system fonts.
+- **Color:** Commit to a cohesive palette using CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Avoid cliched purple gradients on white.
+- **Motion:** Focus on high-impact moments — one well-orchestrated page load with staggered reveals (`animation-delay`) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise. Prefer CSS-only solutions; use Motion library for React when available.
+- **Spatial Composition:** Unexpected layouts — asymmetry, overlap, diagonal flow, grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Depth:** Create atmosphere rather than defaulting to solid colors. Gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, grain overlays.
+
+Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate animations and effects. Minimalist designs need restraint, precision, and careful spacing/typography. No two designs should look the same — vary themes, fonts, and aesthetics across generations.
+
+---
+
+## Clarifying Questions
+
+Ask one question at a time and stop when you have enough context.
+
+### For a Page
+1. Name and purpose?
+2. URL path?
+3. Should it appear in navigation?
+4. Access control? (public, authenticated via `PrivateRoute`, or unauthenticated via `AuthenticationRoute`)
+5. Content sections? (list, form, table, detail view)
+6. Data fetching needs?
+
+### For a Header / Footer
+1. Header, footer, or both?
+2. Contents? (logo, nav links, user avatar, copyright, social icons)
+3. Sticky header?
+4. Color scheme or style direction?
+
+### For a Component
+1. What should it do?
+2. Which page does it belong to?
+3. Shared/reusable or specific to one feature?
+4. Data or props needed?
+5. Internal state? (loading, toggle, form state)
+6. Specific shadcn components to use?
+
+---
+
+## Verification
+
+Before completing, run lint and build from the UI bundle directory. Lint must result in 0 errors and build must succeed.

package/skills/{building-webapp-react-components → building-ui-bundle-frontend}/implementation/component.md

@@ -64,7 +64,7 @@ export default function HomePage() {
 
 ### Useful Patterns — Component
 
-- **Programmatic navigation:** use `useNavigate` from `react-router`; call `navigate(path)` — consistent with GlobalSearchInput, SearchResultCard, MaintenanceTable, and other components in the web application.
+- **Programmatic navigation:** use `useNavigate` from `react-router`; call `navigate(path)` — consistent with GlobalSearchInput, SearchResultCard, MaintenanceTable, and other components in the UI bundle.
 - **Page container:** `max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12`
 - **Icons:** `lucide-react`; add `aria-hidden="true"` on decorative icons
 - **Focus styles:** use `focus-visible:` variants

package/skills/creating-b2b-commerce-store/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: creating-b2b-commerce-store
+description: "Interactive workflow to create Commerce B2B Stores and retrieve storefront metadata. Use when users want to: create B2B Commerce stores, build Commerce storefronts, set up B2B stores from Vibes, retrieve Commerce metadata, deploy Commerce experiences, work with DigitalExperienceBundle for Commerce."
+Critical: "Agents must follow the interactive flow and NEVER create storefront metadata from scratch."
+license: Apache-2.0
+compatibility: "Requires Commerce licenses, Experience Cloud, Salesforce CLI"
+metadata:
+  version: "1.0"
+  category: "commerce"
+---
+
+# Commerce B2B Storefront Creation
+
+Interactive workflow to create a Commerce B2B Store in Salesforce and retrieve the auto-generated storefront metadata to your repository.
+
+## Critical Concepts
+
+Commerce B2B = Store (backend data) + Storefront (frontend metadata). **Store must be created first** in the org to auto-generate the Storefront. Never create storefront metadata manually.
+
+> See [Store vs Storefront Reference](references/store-vs-storefront.md)
+
+## When to Use This Skill
+
+Trigger when users request:
+- "Create a B2B Commerce store"
+- "Build a Commerce storefront"
+- "Set up Commerce B2B"
+- "Create B2B Commerce"
+- "Retrieve Commerce storefront metadata"
+- "Deploy B2B storefront"
+
+## Rules That Always Apply
+
+1. **Always follow the interactive flow.** Do NOT skip steps. Each step requires user confirmation before proceeding.
+
+2. **Never create storefront metadata manually.** The Commerce setup wizard generates hundreds of configuration values. Manual creation will fail.
+
+3. **Always list sites before retrieval.** Store names get underscores and number suffixes (e.g., "My B2B Store" → "My_B2B_Store1"). Let the user select from the actual list.
+
+4. **Always use `--json` flag.** Include `--json` on all Salesforce CLI commands for parseable output.
+
+## Interactive Workflow: 7 Steps
+
+### Step 1: Explain Commerce B2B Concept
+
+**Agent explains:** Commerce has Store (data) + Storefront (metadata). Store must be created first.
+
+> See: [Store vs Storefront Reference](references/store-vs-storefront.md)
+
+---
+
+### Step 2: Guide User to Create B2B Store
+
+**Agent provides these steps:**
+
+1. Navigate to **Setup → Commerce → Stores**
+   - Or: **App Launcher → Commerce → Create Store**
+
+2. Click **"Create Store"** or **"Setup New Store"**
+
+3. Select **"Commerce Store"** as the store type
+
+4. Follow the wizard:
+   - **Store Name**: Choose descriptive name (e.g., "My B2B Store")
+     - Important: Spaces become underscores in folder names
+   - **Site URL**: Unique URL name for the site 
+
+5. Complete wizard - it creates:
+   - WebStore record
+   - Default buyer group and entitlement policies
+   - Associated Digital Experience (LWR site)
+
+6. Optional: Configure payment gateway, tax provider, shipping
+
+**Agent then asks:**
+"Have you completed creating the B2B Store in your org? Reply 'yes' when ready and provide the store name you used."
+
+---
+
+### Step 3: Get User Confirmation
+
+**Agent waits for:** User confirmation and store name
+
+**Agent validates:** Store name format (no special characters, spaces will appear as underscores)
+
+**Agent acknowledges:** "Great! Let me list the available storefronts in your org..."
+
+---
+
+### Step 4: List Available LWR Sites
+
+**Agent executes:**
+```bash
+sf org list metadata --metadata-type DigitalExperienceConfig --json
+```
+
+**Agent should:**
+- Parse JSON output to extract site names
+- Display as numbered list
+- Explain naming (underscores, number suffixes)
+
+**Example output:**
+```
+Available Digital Experience sites:
+1. My_B2B_Store1
+2. Partner_Portal
+3. Customer_Community
+```
+
+---
+
+### Step 5: Let User Select Storefront
+
+**Agent asks:**
+"Which site corresponds to your B2B Store? Select the site name:"
+
+**Agent validates:** Selection matches available sites
+
+**Agent confirms:** "Got it! I'll retrieve metadata for [site-name]..."
+
+---
+
+### Step 6: Retrieve Storefront Metadata
+
+**Agent executes:**
+```bash
+sf project retrieve start -m DigitalExperienceBundle:site/<selected-store-name> --json
+```
+
+**Agent should:**
+- Show retrieval progress
+- Confirm successful retrieval
+- List retrieved directory structure
+
+**Expected output:**
+```
+Retrieved: force-app/main/default/digitalExperiences/site/My_B2B_Store1/
+├── My_B2B_Store1.digitalExperience-meta.xml
+├── sfdc_cms__view/ (home, current_cart, detail_*, list_*, etc.)
+├── sfdc_cms__site/
+├── sfdc_cms__route/
+└── [other sfdc_cms__* directories]
+```
+
+---
+
+### Step 7: Provide Next Steps
+
+**Agent provides:**
+
+✅ **Metadata retrieved successfully!**
+
+**Next steps:**
+- Customize with custom LWCs or branding changes
+- Deploy: `sf project deploy start --source-dir force-app/main/default/digitalExperiences/site/My_B2B_Store1/ --json`
+
+**Resources:** [DigitalExperienceBundle Docs](https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_digitalexperiencebundle.htm), [B2B Commerce Guide](https://developer.salesforce.com/docs/atlas.en-us.b2b_commerce_dev_guide.meta/b2b_commerce_dev_guide/)
+
+---
+
+## Reference
+
+- **[store-vs-storefront.md](references/store-vs-storefront.md)** - Technical details on Store vs Storefront, source control, and why manual creation fails
+
+---
+
+## Remember
+
+**Store first (creates storefront) → Retrieve → Customize**