@schandlergarcia/sf-web-components 1.9.48 → 1.9.52

package/.a4drules/webapp-data.md

@@ -0,0 +1,353 @@
+# Salesforce Data Access
+
+- **Fetch or display Salesforce data** — Query records (Account, Contact, Opportunity, custom objects) to show in a component
+- **Create, update, or delete records** — Perform mutations on Salesforce data
+- **Add data fetching to a component** — Wire up a React component to Salesforce data
+- **Call REST APIs** — Use Connect REST, Apex REST, or UI API endpoints
+- **Explore the org schema** — Discover available objects, fields, or relationships
+
+## Data SDK Requirement
+
+> **All Salesforce data access MUST use the Data SDK** (`@salesforce/sdk-data`). The SDK handles authentication, CSRF, and base URL resolution. Never use `fetch()` or `axios` directly.
+
+```typescript
+import { createDataSDK, gql } from "@salesforce/sdk-data";
+
+const sdk = await createDataSDK();
+
+// GraphQL for record queries/mutations (PREFERRED)
+const response = await sdk.graphql?.<ResponseType>(query, variables);
+
+// REST for Connect REST, Apex REST, UI API (when GraphQL insufficient)
+const res = await sdk.fetch?.("/services/apexrest/my-resource");
+```
+
+**Always use optional chaining** (`sdk.graphql?.()`, `sdk.fetch?.()`) — these methods may be undefined in some surfaces.
+
+## Supported APIs
+
+**Only the following APIs are permitted.** Any endpoint not listed here must not be used.
+
+| API | Method | Endpoints / Use Case |
+|-----|--------|----------------------|
+| GraphQL | `sdk.graphql` | All record queries and mutations via `uiapi { }` namespace |
+| UI API REST | `sdk.fetch` | `/services/data/v{ver}/ui-api/records/{id}` — record metadata when GraphQL is insufficient |
+| Apex REST | `sdk.fetch` | `/services/apexrest/{resource}` — custom server-side logic, aggregates, multi-step transactions |
+| Connect REST | `sdk.fetch` | `/services/data/v{ver}/connect/file/upload/config` — file upload config |
+| Einstein LLM | `sdk.fetch` | `/services/data/v{ver}/einstein/llm/prompt/generations` — AI text generation |
+
+**Not supported:**
+
+- **Enterprise REST query endpoint** (`/services/data/v*/query` with SOQL) — blocked at the proxy level. Use GraphQL for record reads; use Apex REST if server-side SOQL aggregates are required.
+- **Aura-enabled Apex** (`@AuraEnabled`) — an LWC/Aura pattern with no invocation path from React webapps.
+- **Chatter API** (`/chatter/users/me`) — use `uiapi { currentUser { ... } }` in a GraphQL query instead.
+- **Any other Salesforce REST endpoint** not listed in the supported table above.
+
+## Decision: GraphQL vs REST
+
+| Need | Method | Example |
+|------|--------|---------|
+| Query/mutate records | `sdk.graphql` | Account, Contact, custom objects |
+| Current user info | `sdk.graphql` | `uiapi { currentUser { Id Name { value } } }` |
+| UI API record metadata | `sdk.fetch` | `/ui-api/records/{id}` |
+| Connect REST | `sdk.fetch` | `/connect/file/upload/config` |
+| Apex REST | `sdk.fetch` | `/services/apexrest/auth/login` |
+| Einstein LLM | `sdk.fetch` | `/einstein/llm/prompt/generations` |
+
+**GraphQL is preferred** for record operations. Use REST only when GraphQL doesn't cover the use case.
+
+---
+
+## GraphQL Workflow
+
+### Step 1: Acquire Schema
+
+The `schema.graphql` file is **already checked into the repo** at the SFDX project root. **Never open or parse it directly.**
+
+- Pre-built from sample data, contains Engine objects (Contact, Trip__c, Flight__c, etc.)
+- No generation needed — just use it
+- If you ever need to regenerate (after adding fields to sample data): `npm run graphql:schema:sample` from webapp dir
+
+### Step 2: Look Up Entity Schema
+
+Map user intent to PascalCase names ("accounts" → `Account`), then **run the search script from the project root**:
+
+```bash
+# From project root — look up all relevant schema info for one or more entities
+bash scripts/graphql-search.sh Account
+
+# Multiple entities at once
+bash scripts/graphql-search.sh Account Contact Opportunity
+```
+
+The script outputs five sections per entity:
+1. **Type definition** — all queryable fields and relationships
+2. **Filter options** — available fields for `where:` conditions
+3. **Sort options** — available fields for `orderBy:`
+4. **Create input** — fields accepted by create mutations
+5. **Update input** — fields accepted by update mutations
+
+Use this output to determine exact field names before writing any query or mutation. **Maximum 2 script runs.** If the entity still can't be found, ask the user — the object may not be deployed.
+
+### Step 3: Generate Query
+
+Use the templates below. Every field name **must** be verified from the script output in Step 2.
+
+#### Read Query Template
+
+```graphql
+query GetAccounts {
+  uiapi {
+    query {
+      Account(where: { Industry: { eq: "Technology" } }, first: 10) {
+        edges {
+          node {
+            Id
+            Name @optional { value }
+            Industry @optional { value }
+            # Parent relationship
+            Owner @optional { Name { value } }
+            # Child relationship
+            Contacts @optional {
+              edges { node { Name @optional { value } } }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**FLS Resilience**: Apply `@optional` to all record fields. The server omits inaccessible fields instead of failing. Consuming code must use optional chaining:
+
+```typescript
+const name = node.Name?.value ?? "";
+```
+
+#### Mutation Template
+
+```graphql
+mutation CreateAccount($input: AccountCreateInput!) {
+  uiapi {
+    AccountCreate(input: $input) {
+      Record { Id Name { value } }
+    }
+  }
+}
+```
+
+**Mutation constraints:**
+- Create: Include required fields, only `createable` fields, no child relationships
+- Update: Include `Id`, only `updateable` fields
+- Delete: Include `Id` only
+
+#### Object Metadata & Picklist Values
+
+Use `uiapi { objectInfos(...) }` to fetch field metadata or picklist values. Pass **either** `apiNames` or `objectInfoInputs` — never both in the same query.
+
+**Object metadata** (field labels, data types, CRUD flags):
+
+```typescript
+const GET_OBJECT_INFO = gql`
+  query GetObjectInfo($apiNames: [String!]!) {
+    uiapi {
+      objectInfos(apiNames: $apiNames) {
+        ApiName
+        label
+        labelPlural
+        fields {
+          ApiName
+          label
+          dataType
+          updateable
+          createable
+        }
+      }
+    }
+  }
+`;
+
+const sdk = await createDataSDK();
+const response = await sdk.graphql?.(GET_OBJECT_INFO, { apiNames: ["Account"] });
+const objectInfos = response?.data?.uiapi?.objectInfos ?? [];
+```
+
+**Picklist values** (use `objectInfoInputs` + `... on PicklistField` inline fragment):
+
+```typescript
+const GET_PICKLIST_VALUES = gql`
+  query GetPicklistValues($objectInfoInputs: [ObjectInfoInput!]!) {
+    uiapi {
+      objectInfos(objectInfoInputs: $objectInfoInputs) {
+        ApiName
+        fields {
+          ApiName
+          ... on PicklistField {
+            picklistValuesByRecordTypeIDs {
+              recordTypeID
+              picklistValues {
+                label
+                value
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+const response = await sdk.graphql?.(GET_PICKLIST_VALUES, {
+  objectInfoInputs: [{ objectApiName: "Account" }],
+});
+const fields = response?.data?.uiapi?.objectInfos?.[0]?.fields ?? [];
+```
+
+### Step 4: Validate & Test
+
+1. **Lint**: `npx eslint <file>` from webapp dir
+2. **Test**: Ask user before testing. For mutations, request input values — never fabricate data.
+
+**If ESLint reports a GraphQL error** (e.g. `Cannot query field`, `Unknown type`, `Unknown argument`), the field or type name is wrong. Re-run the schema search script to find the correct name — do not guess:
+
+```bash
+# From project root — re-check the entity that caused the error
+bash scripts/graphql-search.sh <EntityName>
+```
+
+Then fix the query using the exact names from the script output.
+
+---
+
+## Webapp Integration (React)
+
+```typescript
+import { createDataSDK, gql } from "@salesforce/sdk-data";
+
+const GET_ACCOUNTS = gql`
+  query GetAccounts {
+    uiapi {
+      query {
+        Account(first: 10) {
+          edges {
+            node {
+              Id
+              Name @optional { value }
+              Industry @optional { value }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+const sdk = await createDataSDK();
+const response = await sdk.graphql?.(GET_ACCOUNTS);
+
+if (response?.errors?.length) {
+  throw new Error(response.errors.map(e => e.message).join("; "));
+}
+
+const accounts = response?.data?.uiapi?.query?.Account?.edges?.map(e => e.node) ?? [];
+
+---
+
+## REST API Patterns
+
+Use `sdk.fetch` when GraphQL is insufficient. See the [Supported APIs](#supported-apis) table for the full allowlist.
+
+```typescript
+declare const __SF_API_VERSION__: string;
+const API_VERSION = typeof __SF_API_VERSION__ !== "undefined" ? __SF_API_VERSION__ : "65.0";
+
+// Connect — file upload config
+const res = await sdk.fetch?.(`/services/data/v${API_VERSION}/connect/file/upload/config`);
+
+// Apex REST (no version in path)
+const res = await sdk.fetch?.("/services/apexrest/auth/login", {
+  method: "POST",
+  body: JSON.stringify({ email, password }),
+  headers: { "Content-Type": "application/json" },
+});
+
+// UI API — record with metadata (prefer GraphQL for simple reads)
+const res = await sdk.fetch?.(`/services/data/v${API_VERSION}/ui-api/records/${recordId}`);
+
+// Einstein LLM
+const res = await sdk.fetch?.(`/services/data/v${API_VERSION}/einstein/llm/prompt/generations`, {
+  method: "POST",
+  body: JSON.stringify({ promptTextorId: prompt }),
+});
+```
+
+**Current user**: Do not use Chatter (`/chatter/users/me`). Use GraphQL instead:
+
+```typescript
+const GET_CURRENT_USER = gql`
+  query CurrentUser {
+    uiapi { currentUser { Id Name { value } } }
+  }
+`;
+const response = await sdk.graphql?.(GET_CURRENT_USER);
+```
+
+---
+
+## Directory Structure
+
+```
+<project-root>/                              ← SFDX project root
+├── schema.graphql                           ← grep target (lives here)
+├── sfdx-project.json
+└── force-app/main/default/webapplications/<app-name>/  ← webapp dir
+    ├── package.json                         ← npm scripts
+    └── src/
+```
+
+| Command | Run From | Why |
+|---------|----------|-----|
+| `npm run graphql:schema:sample` | webapp dir | Regenerate schema (rarely needed) |
+| `npx eslint <file>` | webapp dir | Reads eslint.config.js |
+| `bash scripts/graphql-search.sh <Entity>` | project root | Schema lookup |
+| `sf api request rest` | project root | Needs sfdx-project.json |
+
+---
+
+## Quick Reference
+
+### Schema Lookup (from project root)
+
+Run the search script to get all relevant schema info in one step:
+
+```bash
+bash scripts/graphql-search.sh <EntityName>
+```
+
+| Script Output Section | Used For |
+|-----------------------|----------|
+| Type definition | Field names, parent/child relationships |
+| Filter options | `where:` conditions |
+| Sort options | `orderBy:` |
+| CreateRepresentation | Create mutation field list |
+| UpdateRepresentation | Update mutation field list |
+
+### Error Categories
+
+| Error Contains | Resolution |
+|----------------|------------|
+| `Cannot query field` | Field name is wrong — run `graphql-search.sh <Entity>` and use the exact name from the Type definition section |
+| `Unknown type` | Type name is wrong — run `graphql-search.sh <Entity>` to confirm the correct PascalCase entity name |
+| `Unknown argument` | Argument name is wrong — run `graphql-search.sh <Entity>` and check Filter or OrderBy sections |
+| `invalid syntax` | Fix syntax per error message |
+| `validation error` | Field name is wrong — run `graphql-search.sh <Entity>` to verify |
+| `VariableTypeMismatch` | Correct argument type from schema |
+| `invalid cross reference id` | Entity deleted — ask for valid Id |
+
+### Checklist
+
+- [ ] All field names verified via search script (Step 2)
+- [ ] `@optional` applied to record fields (reads)
+- [ ] Optional chaining in consuming code
+- [ ] Lint passes: `npx eslint <file>`

package/.a4drules/webapp-ui.md

@@ -0,0 +1,16 @@
+# UI Platform Rule
+
+**All new UI must be built as a Salesforce Web Application.**
+
+When any task involves creating a new UI, frontend, page, dashboard, form, or user-facing feature:
+
+1. Use `sf webapp generate` to scaffold the web app inside the SFDX project — do not use `create-react-app`, standalone Vite, or any other scaffold.
+2. The app must live under `<sfdx-source>/webapplications/<AppName>/` as a WebApplication bundle.
+3. Do not build new UIs as LWC components, Aura components, or Visualforce pages.
+
+For setup from the project root, use `node scripts/setup-cli.mjs --help` and the options documented there.
+
+## Data Access (MUST FOLLOW)
+
+- **Never hardcode data in the app.** All data displayed in the UI must come from live Salesforce data fetching — no static arrays, mock objects, or placeholder values in production code.
+- **Follow `.a4drules/webapp-data.md`** before writing any data access code. All implementation must match those rules (Data SDK, supported APIs, GraphQL workflow).

package/CHANGELOG.md

@@ -5,6 +5,264 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.52] - 2026-04-01
+
+### Added
+- **data/engine-command-center-prd.md** - Complete PRD for Engine Travel Command Center
+  - Issue: PRD was external documentation, not part of package
+  - Solution: Include PRD in package data, install to webapp root automatically
+  - Enables agents to reference PRD directly without external files
+  - Location after install: `engine-command-center-prd.md` (webapp root)
+  - Sections: Product overview, users, brand tokens, architecture, layout, components, data model, build prompts, anti-patterns
+
+### Changed
+- **scripts/postinstall.mjs** - Now installs Engine PRD to webapp root
+  - Copies `engine-command-center-prd.md` from package data/
+  - Accessible at same level as schema.graphql for easy reference
+  - Updated summary count to include PRD
+
+- **scripts/reset-command-center.sh** - Now restores Engine PRD during reset
+  - Added restoration of `engine-command-center-prd.md`
+  - Updated success message to mention PRD restoration
+
+- **.a4drules/** - Synced all skill files from reactapp4
+  - Updated existing skills: command-center-builder, command-center-project, component-library, outer-app
+  - Added new feature rules:
+    - `features/phase2-data-pattern.md` - Data patterns for Phase 2
+    - `features/pre-code-checklist.md` - Pre-code verification checklist
+  - Added root-level documentation:
+    - `validation-requirements.md` - Validation rules
+    - `webapp-data.md` - Data access patterns
+    - `webapp-ui.md` - UI component patterns
+  - Updated troubleshooting: `troubleshooting/graphql-introspection-failure.md`
+  - Updated dashboard rules: `features/engine-dashboard-rule.md`, `features/command-center-dashboard-rule.md`
+
+### Rationale
+**The Problem:** Engine PRD was maintained separately (in docs/ or at repo root in other projects). Agents had to search for it, and different projects had different versions.
+
+**The Solution:** Include PRD in the package just like sample data and schema:
+1. PRD ships with package in `data/`
+2. Postinstall copies to webapp root
+3. Reset restores it if modified
+4. All projects get the canonical PRD version
+
+**Benefits:**
+- ✅ PRD is always available at `engine-command-center-prd.md`
+- ✅ Agents can reference it without searching
+- ✅ Single source of truth for Engine dashboard specs
+- ✅ Phase 1-4 build prompts included
+- ✅ Anti-patterns documented
+- ✅ Consistent across all projects using the package
+
+**What Gets Installed:**
+```
+webapp-root/
+├── schema.graphql              (6KB - GraphQL schema)
+├── engine-command-center-prd.md (20KB - Complete PRD)
+├── src/
+│   └── data/
+│       └── engine-sample-data.js (31KB - Sample data)
+└── scripts/
+    └── generate-schema-from-sample.mjs (Generator)
+```
+
+### Files Synced from reactapp4
+All .a4drules files updated to latest versions:
+- `skills/command-center-builder/SKILL.md`
+- `skills/command-center-project/SKILL.md`
+- `skills/component-library/SKILL.md`
+- `skills/outer-app/SKILL.md`
+- `features/command-center-dashboard-rule.md`
+- `features/engine-dashboard-rule.md`
+- `features/phase2-data-pattern.md` (new)
+- `features/pre-code-checklist.md` (new)
+- `troubleshooting/graphql-introspection-failure.md`
+- `validation-requirements.md` (new)
+- `webapp-data.md` (new)
+- `webapp-ui.md` (new)
+
+### Migration
+No breaking changes. When users update to v1.9.52:
+- Postinstall automatically copies PRD to webapp root
+- Reset script now restores PRD
+- All .a4drules skills updated to latest versions
+- Existing projects continue working
+
+---
+
+## [1.9.51] - 2026-04-01
+
+### Added
+- **data/schema.graphql** - Pre-built GraphQL schema for Engine Travel Command Center
+  - Issue: Org introspection fails due to null data types in some fields
+  - Solution: Pre-generate schema from sample data field names
+  - Enables GraphQL skills to work without org access
+  - Schema includes: Contact, Trip__c, Flight__c, Booking__c, Disruption__c, Rebooking_Action__c, Travel_Policy__c
+  - All field names match sample data for consistency
+  - Works in CI/CD, no org dependency
+  - 6KB pre-built schema with proper UIAPI structure
+
+- **scripts/generate-schema-from-sample.mjs** - Schema generator script
+  - Creates minimal GraphQL schema from sample data field names
+  - Infers types from field names (String, Float, Boolean, ID)
+  - Generates proper UIAPI structure with connections, filters, pagination
+  - Writes to webapp root: `schema.graphql`
+  - Enables regeneration when sample data fields change
+
+- **.a4drules/troubleshooting/graphql-introspection-failure.md** - Comprehensive troubleshooting guide
+  - Documents org introspection bug and workaround
+  - Explains what still works (queries) vs what's broken (introspection)
+  - Step-by-step manual workaround if needed
+  - Decision tree for when to regenerate schema
+
+- **.a4drules/features/engine-dashboard-rule.md** - Phase 3 implementation rules
+  - Updated to use pre-built schema (no generation needed)
+  - GraphQL skills work out of the box
+  - Sample data as fallback pattern documented
+
+### Changed
+- **scripts/postinstall.mjs** - Now installs GraphQL schema and generator
+  - Copies `schema.graphql` to webapp root
+  - Copies `generate-schema-from-sample.mjs` to webapp scripts/
+  - Adds `graphql:schema:sample` npm script to package.json
+  - Updated summary to show scripts installed
+
+- **scripts/reset-command-center.sh** - Now restores GraphQL schema
+  - Added step 10: restore schema.graphql from package
+  - Handles both installed package and source package locations
+  - Updated success message to mention schema restoration
+
+- **engine-command-center-prd.md** - Simplified Phase 3 prompt
+  - Before: Long explanation about schema generation and fallbacks
+  - After: "Schema is already pre-built - use GraphQL skills normally"
+  - 4-step process instead of complex troubleshooting
+  - Removed DataModeToggle requirement (automatic fallback)
+
+### Rationale
+**The Problem:** Org introspection fails with "cannot invoke FieldDataType.equals(Object) because the return value of Field.getDataType() is null". This breaks:
+- `npm run graphql:schema` (introspection query)
+- IDE autocomplete that queries org directly
+- GraphQL codegen from org schema
+
+But **queries still work** - introspection is just metadata.
+
+**The Solution:** Pre-generate schema from sample data field names:
+1. Sample data already has correct Salesforce field names
+2. Generate schema.graphql from those field names
+3. Check schema into repo (or package)
+4. GraphQL skills use the pre-built schema
+5. Queries execute normally using the same field names
+
+**Benefits:**
+- ✅ Agents don't troubleshoot - schema is ready
+- ✅ Works without org access (CI/CD, offline dev)
+- ✅ GraphQL skills work normally (exploring, generating, using)
+- ✅ IDE tooling works (autocomplete, validation)
+- ✅ Consistent with sample-first approach in Phase 2
+- ✅ Simpler Phase 3 experience
+
+**When to Regenerate:**
+Only when adding new fields to sample data:
+```bash
+npm run graphql:schema:sample  # Updates schema.graphql
+git commit -m "Add new fields to schema"
+```
+
+### Files Included in Package
+New files that ship with sf-web-components:
+- `data/schema.graphql` (6KB)
+- `scripts/generate-schema-from-sample.mjs`
+- `.a4drules/troubleshooting/graphql-introspection-failure.md`
+- `.a4drules/features/engine-dashboard-rule.md`
+
+### Migration
+No breaking changes. When users update to v1.9.51:
+- Postinstall automatically copies schema.graphql and generator script
+- Adds `graphql:schema:sample` to package.json scripts
+- Existing projects continue working
+- Phase 3 builds become simpler (no schema troubleshooting)
+
+---
+
+## [1.9.50] - 2026-04-01
+
+### Added
+- **scripts/postinstall.mjs** - Now copies engine-sample-data.js to src/data/ on installation
+  - Issue: Phase 2 of Engine PRD required manually creating sample data file
+  - Solution: Automatically install pre-built sample data during package setup
+  - Sample data includes all Salesforce-shaped records and dashboard-ready derivatives
+  - File location: `src/data/engine-sample-data.js` (31KB of ready-to-use data)
+  - Eliminates manual data creation step from Phase 2 build process
+
+- **scripts/reset-command-center.sh** - Now restores engine-sample-data.js during reset
+  - Issue: Reset could leave app with modified or missing sample data
+  - Solution: Added step 10 that copies fresh engine-sample-data.js from package
+  - Handles both installed package and source package locations
+  - Ensures consistent data state across resets
+
+### Changed
+- **engine-command-center-prd.md** - Updated Phase 2 prompt to use pre-installed data
+  - Before: "Create `src/data/engine-sample-data.js` with travelers, flights..."
+  - After: "Build components using the pre-installed sample data at `src/data/engine-sample-data.js`"
+  - Simplified Phase 2: just import and use, no data creation needed
+
+- **Postinstall summary** - Now reports data files installed
+  - Added line: "Installed X sample data files"
+
+- **Reset success message** - Now highlights sample data restoration
+  - Added: "Engine sample data (engine-sample-data.js)"
+
+### Rationale
+The engine-sample-data.js file (31KB) contains complete, dashboard-ready data for all Engine Travel Command Center components:
+- Raw Salesforce records (Contact, Trip__c, Flight__c, Booking__c, Disruption__c, etc.)
+- Pre-computed dashboard derivatives (MAP_MARKERS, MAP_ARCS, TRAVELER_CARDS, etc.)
+- All field names match the org schema for easy live-data swap in Phase 3
+
+Installing this automatically:
+- Eliminates a 30+ minute manual data-creation step from Phase 2
+- Ensures all developers use the same sample data
+- Makes the Phase 2 prompt simpler and faster
+- Consistent with how we handle other templates (Home.tsx, routes.tsx, etc.)
+
+Restoring on reset:
+- Prevents issues where modified sample data breaks demo builds
+- Keeps data in sync with global.css, templates, and structure
+- Allows developers to experiment with data changes and easily revert
+
+---
+
+## [1.9.49] - 2026-04-01
+
+### Added
+- **scripts/reset-command-center.sh** - Now restores Engine-branded global.css during reset
+  - Issue: Reset didn't touch global.css, leaving inconsistent styling state
+  - Solution: Added step 9 that writes complete Engine-branded global.css template
+  - Includes all Engine brand tokens:
+    - `--color-engine-*` tokens (teal, coral, green, savings, etc.)
+    - `--color-brand-*` palette (12 teal shades from 50-950)
+    - Inter font stack (`--font-sans`)
+    - JetBrains Mono (`--font-mono`)
+    - Engine border radius tokens (`--radius-pill`, `--radius-card`)
+    - Complete `.heroui-scope` theme overrides with Engine colors
+  - Ensures consistent Engine branding across all reset operations
+  - Template sourced from enginewebexperience production configuration
+
+### Changed
+- **Reset success message** - Updated to highlight Engine branding restoration
+  - Before: "Everything preserved: Theme (global.css + initialMode)"
+  - After: "Restored: Engine brand theme (global.css)" with brand details
+  - Clarifies that reset actively restores Engine branding, not just preserves it
+
+### Rationale
+The reset script is tooling specifically for Engine Travel Command Center development. Making it restore Engine branding by default is consistent with:
+- The script's existing opinionated behavior (specific templates for Home, Search, routes)
+- The engine-command-center-prd.md PRD section 3 which specifies Engine brand tokens
+- The fact that the script lives in sf-web-components package used for Engine dashboards
+
+This eliminates a common source of confusion where developers would reset the app structure but be left with mismatched or baseline styling.
+
+---
+
 ## Critical History: Component Naming Crisis (v1.9.29 - v1.9.42)
 
 ### The Problem