@dainamite/cpq 0.2.2 → 0.4.0

package/src/modules/cpq/backend/cpq/offerings/[id]/page.tsx

@@ -5,7 +5,9 @@ import { useParams, useRouter } from 'next/navigation'
 import { Alert } from '@open-mercato/ui/primitives/alert'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { Tag } from '@open-mercato/ui/primitives/tag'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
 import { NumberInput } from '../../../../components/NumberInput'
+import { normalizeChargePricing } from '../../../../data/charge-pricing'
 import {
   chargeTypeMap,
   formatStatusLabel,
@@ -63,6 +65,7 @@ type Charge = {
   name: string
   description: string | null
   chargeType: string
+  chargeModel: string | null
   pricingMethod: string
   pricingTableId: string | null
   priceColumnKey: string | null
@@ -98,6 +101,22 @@ type Specification = {
 
 type PricingTableRef = { id: string; code: string; name: string; dimensions: Array<{ key: string; label: string }>; priceColumns: Array<{ key: string; label: string }> }
 
+// Shared by the eager mount-load and the lazy editor dropdown. Returns [] on
+// failure so a transient error degrades gracefully instead of blanking the page.
+async function fetchPricingTables(): Promise<PricingTableRef[]> {
+  try {
+    const { ok, result } = await apiCall<{ items?: PricingTableRef[] }>('/api/cpq/pricing-tables?pageSize=100')
+    if (!ok) {
+      console.warn('[cpq] Failed to load pricing tables for the charges list')
+      return []
+    }
+    return result?.items ?? []
+  } catch (err) {
+    console.warn('[cpq] Failed to load pricing tables for the charges list:', err)
+    return []
+  }
+}
+
 type EditingCharge = Omit<Charge, 'id'> & { id?: string }
 
 // ─── Defaults ───────────────────────────────────────────────────
@@ -119,7 +138,8 @@ const EMPTY_CHARGE: EditingCharge = {
   name: '',
   description: null,
   chargeType: 'mrc',
-  pricingMethod: 'flat',
+  chargeModel: 'flat',
+  pricingMethod: 'fixed',
   pricingTableId: null,
   priceColumnKey: null,
   fixedPrice: null,
@@ -131,17 +151,24 @@ const EMPTY_CHARGE: EditingCharge = {
 }
 
 
-const PRICING_METHOD_LABELS: Record<string, string> = {
-  flat: 'flat price',
-  fixed: 'flat price', // legacy alias — see validators.ts
-  per_unit: 'per unit',
-  tiered: 'tiered',
+// XD-297: the charge "shape" is two axes — Charge Model (how quantity drives
+// the charge) and Pricing Method (where the unit price comes from).
+const CHARGE_MODEL_LABELS: Record<string, string> = {
+  flat: 'Flat Fee',
+  per_unit: 'Per Unit',
+  volume: 'Volume-based',
+  tiered: 'Tiered',
 }
 
-// V-CHG-1 in `validators.ts`: per_unit/tiered need table + column + qty
-// attribute; flat needs fixedPrice + currencyCode. Mirror it in the UI so
-// users see what's missing without round-tripping to the server.
+const PRICING_SOURCE_LABELS: Record<string, string> = {
+  fixed: 'Fixed Price',
+  table: 'Table Lookup',
+}
+
+// V-CHG-1 in `validators.ts`: mirror the (chargeModel × pricingMethod) rules in
+// the UI so users see what's missing without round-tripping to the server.
 type ChargeShape = {
+  chargeModel: string | null
   pricingMethod: string
   pricingTableId: string | null
   priceColumnKey: string | null
@@ -155,15 +182,16 @@ function isChargeComplete(charge: ChargeShape): boolean {
 }
 
 function chargeMissingFields(charge: ChargeShape): string[] {
-  const method = charge.pricingMethod === 'fixed' ? 'flat' : charge.pricingMethod
+  const { model, source } = normalizeChargePricing(charge)
   const missing: string[] = []
-  if (method === 'flat') {
+  if (source === 'fixed') {
     if (!charge.fixedPrice) missing.push('Fixed Price')
     if (!charge.currencyCode) missing.push('Currency')
-  } else if (method === 'per_unit' || method === 'tiered') {
+    if (model === 'per_unit' && !charge.quantityAttributeCode) missing.push('Quantity Attribute')
+  } else {
     if (!charge.pricingTableId) missing.push('Pricing Table')
     if (!charge.priceColumnKey) missing.push('Price Column')
-    if (!charge.quantityAttributeCode) missing.push('Quantity Attribute')
+    if (model !== 'flat' && !charge.quantityAttributeCode) missing.push('Quantity Attribute')
   }
   return missing
 }
@@ -245,6 +273,14 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
           setSpecDetail(data.specification ?? null)
           setComponents(data.components ?? [])
 
+          // Charges reference pricing tables by id; load the tables up front so
+          // the list renders their names instead of "missing". The charge editor
+          // also lazy-loads them, but the read view needs them on mount/refresh.
+          if ((data.charges ?? []).some((c) => c.pricingTableId)) {
+            const tables = await fetchPricingTables()
+            if (!cancelled) setPricingTables(tables)
+          }
+
           // Load attributes for the spec
           if (data.specId) {
             const attrRes = await fetch(`/api/cpq/product-attributes?specId=${encodeURIComponent(data.specId)}&pageSize=200`)
@@ -362,16 +398,18 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
 
   const loadPricingTables = async () => {
     if (pricingTables.length > 0) return
-    const res = await fetch('/api/cpq/pricing-tables?pageSize=200')
-    if (res.ok) {
-      const data = await res.json()
-      setPricingTables(data.items ?? [])
-    }
+    setPricingTables(await fetchPricingTables())
   }
 
   const startEditCharge = (charge?: Charge) => {
-    const editing = charge ? { ...charge } : { ...EMPTY_CHARGE }
-    setEditingCharge(editing)
+    if (charge) {
+      // Normalise legacy rows (chargeModel null, combined pricingMethod) into
+      // the split shape the form's two dropdowns expect.
+      const { model, source } = normalizeChargePricing(charge)
+      setEditingCharge({ ...charge, chargeModel: model, pricingMethod: source })
+    } else {
+      setEditingCharge({ ...EMPTY_CHARGE })
+    }
     loadPricingTables()
   }
 
@@ -759,22 +797,55 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
                     <option value="usage">Usage</option>
                   </select>
                 </div>
+                <div>
+                  <label className="block text-xs font-medium mb-1">Charge Model</label>
+                  <select
+                    value={editingCharge.chargeModel ?? 'flat'}
+                    onChange={(e) => {
+                      const model = e.target.value
+                      const next = { ...editingCharge, chargeModel: model }
+                      // Volume / tiered are graduated over table ranges — they can't use a fixed price.
+                      if ((model === 'volume' || model === 'tiered') && editingCharge.pricingMethod !== 'table') {
+                        next.pricingMethod = 'table'
+                        next.fixedPrice = null
+                      }
+                      // Flat never takes a quantity attribute.
+                      if (model === 'flat') next.quantityAttributeCode = null
+                      setEditingCharge(next)
+                    }}
+                    className="w-full rounded-md border px-2 py-1.5 text-sm"
+                  >
+                    <option value="flat">Flat Fee</option>
+                    <option value="per_unit">Per Unit</option>
+                    <option value="volume">Volume-based</option>
+                    <option value="tiered">Tiered</option>
+                  </select>
+                </div>
                 <div>
                   <label className="block text-xs font-medium mb-1">Pricing Method</label>
-                  <select value={editingCharge.pricingMethod} onChange={(e) => {
-                    const method = e.target.value
-                    if (method === 'flat') {
-                      setEditingCharge({ ...editingCharge, pricingMethod: method, pricingTableId: null, priceColumnKey: null, quantityAttributeCode: null })
-                    } else {
-                      setEditingCharge({ ...editingCharge, pricingMethod: method, fixedPrice: null })
-                    }
-                  }} className="w-full rounded-md border px-2 py-1.5 text-sm">
-                    <option value="flat">Flat Price</option>
-                    <option value="per_unit">Per Unit (table lookup)</option>
-                    <option value="tiered">Tiered (table lookup)</option>
+                  <select
+                    value={editingCharge.pricingMethod}
+                    onChange={(e) => {
+                      const source = e.target.value
+                      if (source === 'fixed') {
+                        // Only per_unit keeps the quantity attribute under a fixed
+                        // price; flat must drop it (V-CHG-1 forbids it).
+                        const keepQty = editingCharge.chargeModel === 'per_unit'
+                        setEditingCharge({ ...editingCharge, pricingMethod: source, pricingTableId: null, priceColumnKey: null, ...(keepQty ? {} : { quantityAttributeCode: null }) })
+                      } else {
+                        setEditingCharge({ ...editingCharge, pricingMethod: source, fixedPrice: null })
+                      }
+                    }}
+                    className="w-full rounded-md border px-2 py-1.5 text-sm"
+                  >
+                    {/* Volume / tiered are graduated over table ranges — a fixed price isn't applicable. */}
+                    {editingCharge.chargeModel !== 'volume' && editingCharge.chargeModel !== 'tiered' && (
+                      <option value="fixed">Fixed Price</option>
+                    )}
+                    <option value="table">Table Lookup</option>
                   </select>
                 </div>
-                {(editingCharge.pricingMethod === 'flat' || editingCharge.pricingMethod === 'fixed') ? (
+                {editingCharge.pricingMethod === 'fixed' ? (
                   <>
                     <div>
                       <label className="block text-xs font-medium mb-1">Fixed Price <span className="text-destructive">*</span></label>
@@ -799,7 +870,7 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
                         <p className="text-xs text-warning mt-0.5">
                           No pricing tables yet —{' '}
                           <a href="/backend/cpq/pricing-tables" className="text-primary hover:underline">create one</a>{' '}
-                          before using {editingCharge.pricingMethod} pricing.
+                          before using Table Lookup pricing.
                         </p>
                       )}
                     </div>
@@ -812,27 +883,32 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
                         ))}
                       </select>
                     </div>
-                    <div>
-                      <label className="block text-xs font-medium mb-1">Quantity Attribute <span className="text-destructive">*</span></label>
-                      <select value={editingCharge.quantityAttributeCode ?? ''} onChange={(e) => setEditingCharge({ ...editingCharge, quantityAttributeCode: e.target.value || null })} className="w-full rounded-md border px-2 py-1.5 text-sm">
-                        <option value="">Select attribute...</option>
-                        {attributes.filter((a) => a.attributeType === 'number').map((a) => (
-                          <option key={a.code} value={a.code}>{a.name} ({a.code})</option>
-                        ))}
-                      </select>
-                      <p className="text-xs text-muted-foreground mt-0.5">Attribute whose value drives the quantity for pricing</p>
-                      {attributes.filter((a) => a.attributeType === 'number').length === 0 && form.specId && (
-                        <p className="text-xs text-warning mt-0.5">
-                          Spec has no number attributes —{' '}
-                          <a href={`/backend/cpq/specifications/${form.specId}`} className="text-primary hover:underline">
-                            add one to the spec
-                          </a>{' '}
-                          first.
-                        </p>
-                      )}
-                    </div>
                   </>
                 )}
+                {/* Quantity attribute drives the unit count — needed for per-unit
+                    (any source) and for volume / tiered table lookups. */}
+                {((editingCharge.pricingMethod === 'table' && editingCharge.chargeModel !== 'flat') ||
+                  (editingCharge.pricingMethod === 'fixed' && editingCharge.chargeModel === 'per_unit')) && (
+                  <div>
+                    <label className="block text-xs font-medium mb-1">Quantity Attribute <span className="text-destructive">*</span></label>
+                    <select value={editingCharge.quantityAttributeCode ?? ''} onChange={(e) => setEditingCharge({ ...editingCharge, quantityAttributeCode: e.target.value || null })} className="w-full rounded-md border px-2 py-1.5 text-sm">
+                      <option value="">Select attribute...</option>
+                      {attributes.filter((a) => a.attributeType === 'number').map((a) => (
+                        <option key={a.code} value={a.code}>{a.name} ({a.code})</option>
+                      ))}
+                    </select>
+                    <p className="text-xs text-muted-foreground mt-0.5">Attribute whose value drives the quantity for pricing</p>
+                    {attributes.filter((a) => a.attributeType === 'number').length === 0 && form.specId && (
+                      <p className="text-xs text-warning mt-0.5">
+                        Spec has no number attributes —{' '}
+                        <a href={`/backend/cpq/specifications/${form.specId}`} className="text-primary hover:underline">
+                          add one to the spec
+                        </a>{' '}
+                        first.
+                      </p>
+                    )}
+                  </div>
+                )}
                 <div>
                   <label className="block text-xs font-medium mb-1">Sort Order</label>
                   <NumberInput
@@ -902,7 +978,7 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
                     const qtyAttr = charge.quantityAttributeCode
                       ? attributes.find((a) => a.code === charge.quantityAttributeCode)
                       : null
-                    const isFlat = charge.pricingMethod === 'flat' || charge.pricingMethod === 'fixed'
+                    const { model, source } = normalizeChargePricing(charge)
                     return (
                       <tr key={charge.id} className="border-b">
                         <td className="px-4 py-3 font-mono text-xs">{charge.code}</td>
@@ -917,22 +993,35 @@ export default function OfferingDetailPage(props: { params?: { id?: string } })
                             {charge.chargeType.toUpperCase()}
                           </Tag>
                         </td>
-                        <td className="px-4 py-3 text-xs">{PRICING_METHOD_LABELS[charge.pricingMethod] ?? charge.pricingMethod}</td>
                         <td className="px-4 py-3 text-xs">
-                          {isFlat ? (
-                            charge.fixedPrice != null
-                              ? `${charge.currencyCode ?? 'USD'} ${charge.fixedPrice}`
-                              : <span className="text-muted-foreground">—</span>
+                          {CHARGE_MODEL_LABELS[model] ?? model}
+                          <span className="text-muted-foreground"> · {PRICING_SOURCE_LABELS[source] ?? source}</span>
+                        </td>
+                        <td className="px-4 py-3 text-xs">
+                          {source === 'fixed' ? (
+                            <div className="flex flex-col gap-0.5">
+                              {charge.fixedPrice != null
+                                ? <span>{`${charge.currencyCode ?? 'USD'} ${charge.fixedPrice}`}</span>
+                                : <span className="text-muted-foreground">—</span>}
+                              {model === 'per_unit' && (
+                                <span>
+                                  <span className="text-muted-foreground">× Qty:</span>{' '}
+                                  {qtyAttr ? `${qtyAttr.name} (${qtyAttr.code})` : <span className="text-destructive">missing</span>}
+                                </span>
+                              )}
+                            </div>
                           ) : (
                             <div className="flex flex-col gap-0.5">
                               <span>
                                 <span className="text-muted-foreground">Table:</span>{' '}
                                 {tableRef ? `${tableRef.name} → ${charge.priceColumnKey ?? '?'}` : <span className="text-destructive">missing</span>}
                               </span>
-                              <span>
-                                <span className="text-muted-foreground">× Qty:</span>{' '}
-                                {qtyAttr ? `${qtyAttr.name} (${qtyAttr.code})` : <span className="text-destructive">missing</span>}
-                              </span>
+                              {model !== 'flat' && (
+                                <span>
+                                  <span className="text-muted-foreground">× Qty:</span>{' '}
+                                  {qtyAttr ? `${qtyAttr.name} (${qtyAttr.code})` : <span className="text-destructive">missing</span>}
+                                </span>
+                              )}
                             </div>
                           )}
                         </td>

package/src/modules/cpq/backend/cpq/pricing/[id]/EntriesEditor.tsx

@@ -247,6 +247,13 @@ export function EntriesEditor({
           <table className="w-full text-sm">
             <thead>
               <tr className="border-b bg-muted/50">
+                {table.dimensions.map((dim) => (
+                  <th key={dim.key} className="px-3 py-3 text-left font-medium whitespace-nowrap">
+                    {dim.label}
+                  </th>
+                ))}
+                {/* Tier / range columns sit between the dimension lookups and the
+                    prices they qualify, so the row reads "what → how much". */}
                 {hasTieredEntries && (
                   <>
                     <th className="px-3 py-3 text-left font-medium whitespace-nowrap">Tier #</th>
@@ -254,11 +261,6 @@ export function EntriesEditor({
                     <th className="px-3 py-3 text-left font-medium whitespace-nowrap">Range To</th>
                   </>
                 )}
-                {table.dimensions.map((dim) => (
-                  <th key={dim.key} className="px-3 py-3 text-left font-medium whitespace-nowrap">
-                    {dim.label}
-                  </th>
-                ))}
                 {table.priceColumns.map((col) => (
                   <th key={col.key} className="px-3 py-3 text-right font-medium whitespace-nowrap">
                     {col.label}
@@ -314,6 +316,23 @@ function EntryRow({
 
   return (
     <tr className={`border-b hover:bg-muted/30 ${rowBg}`}>
+      {table.dimensions.map((dim) => (
+        <td key={dim.key} className="px-3 py-2">
+          {readOnly ? (
+            entry.dimensionValues?.[dim.key] ?? '—'
+          ) : (
+            <Input
+              value={entry.dimensionValues?.[dim.key] ?? ''}
+              onChange={(e) =>
+                onChange({
+                  dimensionValues: { ...entry.dimensionValues, [dim.key]: e.target.value },
+                })
+              }
+              className="w-28 h-8"
+            />
+          )}
+        </td>
+      ))}
       {hasTieredEntries && (
         <>
           <td className="px-3 py-2">
@@ -355,23 +374,6 @@ function EntryRow({
           </td>
         </>
       )}
-      {table.dimensions.map((dim) => (
-        <td key={dim.key} className="px-3 py-2">
-          {readOnly ? (
-            entry.dimensionValues?.[dim.key] ?? '—'
-          ) : (
-            <Input
-              value={entry.dimensionValues?.[dim.key] ?? ''}
-              onChange={(e) =>
-                onChange({
-                  dimensionValues: { ...entry.dimensionValues, [dim.key]: e.target.value },
-                })
-              }
-              className="w-28 h-8"
-            />
-          )}
-        </td>
-      ))}
       {table.priceColumns.map((col) => (
         <td key={col.key} className="px-3 py-2 text-right font-mono">
           {readOnly ? (

package/src/modules/cpq/backend/cpq/specifications/[id]/page.tsx

@@ -999,7 +999,10 @@ export default function SpecificationDetailPage(props: { params?: { id?: string
                 </div>
                 <div>
                   <label className="block text-xs font-medium mb-1">Type</label>
-                  <select value={editingAttr.attributeType} onChange={(e) => setEditingAttr({ ...editingAttr, attributeType: e.target.value })} className="w-full rounded-md border px-2 py-1.5 text-sm">
+                  {/* Reset the default when the type changes — a default kept from a
+                      different type (e.g. a numeric default on a now-boolean attr)
+                      would be invalid and confusing. */}
+                  <select value={editingAttr.attributeType} onChange={(e) => setEditingAttr({ ...editingAttr, attributeType: e.target.value, defaultValue: null })} className="w-full rounded-md border px-2 py-1.5 text-sm">
                     <option value="text">Text</option>
                     <option value="number">Number</option>
                     <option value="boolean">Boolean</option>
@@ -1027,6 +1030,75 @@ export default function SpecificationDetailPage(props: { params?: { id?: string
                   <label className="block text-xs font-medium mb-1">Help Text</label>
                   <input type="text" value={editingAttr.helpText ?? ''} onChange={(e) => setEditingAttr({ ...editingAttr, helpText: e.target.value || null })} className="w-full rounded-md border px-2 py-1.5 text-sm" />
                 </div>
+                {/* Reference attributes resolve to an FK UUID at run-time, so a
+                    free-text scalar default has no sensible meaning — omit the
+                    field entirely for them. */}
+                {editingAttr.attributeType !== 'reference' && (
+                  <div>
+                    <label className="block text-xs font-medium mb-1">{t('cpq.specifications.defaultValue', 'Default Value')}</label>
+                    {editingAttr.attributeType === 'number' ? (
+                      <NumberInput
+                        value={typeof editingAttr.defaultValue === 'number' ? editingAttr.defaultValue : null}
+                        onChange={(n) => setEditingAttr({ ...editingAttr, defaultValue: n })}
+                        placeholder={t('cpq.specifications.noDefault', 'No default')}
+                      />
+                    ) : editingAttr.attributeType === 'boolean' ? (
+                      <select
+                        value={editingAttr.defaultValue === true ? 'true' : editingAttr.defaultValue === false ? 'false' : ''}
+                        onChange={(e) => setEditingAttr({ ...editingAttr, defaultValue: e.target.value === '' ? null : e.target.value === 'true' })}
+                        className="w-full rounded-md border px-2 py-1.5 text-sm"
+                      >
+                        <option value="">{t('cpq.specifications.noDefault', 'No default')}</option>
+                        <option value="true">{t('cpq.specifications.booleanTrue', 'True')}</option>
+                        <option value="false">{t('cpq.specifications.booleanFalse', 'False')}</option>
+                      </select>
+                    ) : (editingAttr.attributeType === 'select' || editingAttr.attributeType === 'multi-select') ? (
+                      <>
+                        <select
+                          multiple={editingAttr.attributeType === 'multi-select'}
+                          value={
+                            editingAttr.attributeType === 'multi-select'
+                              ? (Array.isArray(editingAttr.defaultValue) ? editingAttr.defaultValue.map(String) : [])
+                              : (editingAttr.defaultValue == null ? '' : String(editingAttr.defaultValue))
+                          }
+                          onChange={(e) => {
+                            if (editingAttr.attributeType === 'multi-select') {
+                              const vals = Array.from(e.target.selectedOptions).map((o) => o.value).filter((v) => v !== '')
+                              setEditingAttr({ ...editingAttr, defaultValue: vals.length ? vals : null })
+                            } else {
+                              setEditingAttr({ ...editingAttr, defaultValue: e.target.value === '' ? null : e.target.value })
+                            }
+                          }}
+                          className="w-full rounded-md border px-2 py-1.5 text-sm"
+                        >
+                          {/* `multiple` selects can't carry a placeholder row, so only the
+                              single-select variant gets an explicit "No default" option. */}
+                          {editingAttr.attributeType === 'select' && <option value="">{t('cpq.specifications.noDefault', 'No default')}</option>}
+                          {editingOptions
+                            .filter((o) => o.value.trim() !== '')
+                            .map((o) => (
+                              <option key={o.value} value={o.value}>
+                                {o.label || o.value}
+                              </option>
+                            ))}
+                        </select>
+                        {editingAttr.attributeType === 'multi-select' && (
+                          <p className="text-xs text-muted-foreground mt-1">
+                            {t('cpq.specifications.multiSelectDefaultHint', 'Ctrl/Cmd-click to select several, or deselect all to clear the default.')}
+                          </p>
+                        )}
+                      </>
+                    ) : (
+                      <input
+                        type="text"
+                        value={editingAttr.defaultValue == null ? '' : String(editingAttr.defaultValue)}
+                        onChange={(e) => setEditingAttr({ ...editingAttr, defaultValue: e.target.value === '' ? null : e.target.value })}
+                        placeholder={t('cpq.specifications.noDefault', 'No default')}
+                        className="w-full rounded-md border px-2 py-1.5 text-sm"
+                      />
+                    )}
+                  </div>
+                )}
                 {editingAttr.attributeType === 'reference' && (
                   <>
                     <div>

package/src/modules/cpq/cli.ts

@@ -1,10 +1,89 @@
 import type { ModuleCli } from '@open-mercato/shared/modules/registry'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { seedCpqDemo } from './lib/seeds/demo'
 
-const seedCommand: ModuleCli = {
+/**
+ * `mercato cpq seed [--reset] [--tenant <id>] [--org <id>]`
+ *
+ * Loads a minimal, neutral CPQ test catalog (product + specification +
+ * offering + charge) into a single tenant. With no `--tenant`/`--org` it
+ * resolves the first (primary) organization created by `mercato init`.
+ * `--reset` clears the seed's own rows first.
+ *
+ * For rich, vertical demo catalogs use `mercato demo_tenants seed --all`.
+ */
+
+function parseArgs(rest: string[]): Record<string, string | boolean> {
+  const out: Record<string, string | boolean> = {}
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i]
+    if (!token || !token.startsWith('--')) continue
+    const key = token.slice(2)
+    const next = rest[i + 1]
+    if (next === undefined || next.startsWith('--')) out[key] = true
+    else {
+      out[key] = next
+      i++
+    }
+  }
+  return out
+}
+
+async function resolveScope(
+  em: EntityManager,
+  args: Record<string, string | boolean>,
+): Promise<{ tenantId: string; organizationId: string } | null> {
+  const orgArg = typeof args.org === 'string' ? args.org : undefined
+  const tenantArg = typeof args.tenant === 'string' ? args.tenant : undefined
+
+  const { Organization } = await import('@open-mercato/core/modules/directory/data/entities')
+
+  if (orgArg) {
+    const org = await em.findOne(Organization, { id: orgArg } as never)
+    if (!org) return null
+    return { organizationId: org.id, tenantId: tenantArg ?? org.tenant.id }
+  }
+
+  const orgs = await em.find(
+    Organization,
+    { isActive: true } as never,
+    { orderBy: { createdAt: 'asc' } as never, limit: 5 },
+  )
+  if (orgs.length === 0) return null
+  const org = orgs[0]
+  if (orgs.length > 1) {
+    console.warn(
+      `[cpq seed] Multiple organizations found — defaulting to "${org.name}" (${org.id}). ` +
+        `Pass --org <id> to target another.`,
+    )
+  }
+  return { organizationId: org.id, tenantId: tenantArg ?? org.tenant.id }
+}
+
+const seed: ModuleCli = {
   command: 'seed',
-  async run() {
-    console.log('CPQ seed: no default seed data. Configure specifications, offerings, and pricing via the admin UI.')
+  async run(rest) {
+    const args = parseArgs(rest)
+    const reset = Boolean(args.reset)
+
+    const container = await createRequestContainer()
+    const em = container.resolve<EntityManager>('em')
+
+    const scope = await resolveScope(em, args)
+    if (!scope) {
+      console.error('[cpq seed] No organization found. Run "yarn initialize" first, or pass --org <id>.')
+      return
+    }
+
+    const res = await seedCpqDemo(em, scope, { reset })
+    console.log(
+      `[cpq seed] tenant=${scope.tenantId} org=${scope.organizationId}${reset ? ' (reset)' : ''}\n` +
+        `  ✓ products +${res.productsCreated}, specs +${res.specsCreated}, ` +
+        `offerings +${res.offeringsCreated}, charges +${res.chargesCreated} (existing rows left untouched)\n` +
+        `  → Backend · CPQ · Product Specifications / Product Offerings.`,
+    )
   },
 }
 
-export default [seedCommand]
+export default [seed]

package/src/modules/cpq/data/__tests__/charge-pricing.test.ts

@@ -0,0 +1,49 @@
+import { normalizeChargePricing } from '../charge-pricing'
+
+// Pins the documented decision table for the legacy-disambiguation logic.
+describe('normalizeChargePricing', () => {
+  it('legacy flat without a table → fixed / flat', () => {
+    expect(normalizeChargePricing({ pricingMethod: 'flat' })).toEqual({ model: 'flat', source: 'fixed' })
+  })
+
+  it('legacy flat with a pricingTableId → table / flat (preserves calculateFlat-via-table)', () => {
+    expect(normalizeChargePricing({ pricingMethod: 'flat', pricingTableId: 't1' })).toEqual({ model: 'flat', source: 'table' })
+  })
+
+  it('legacy per_unit → table / per_unit', () => {
+    expect(normalizeChargePricing({ pricingMethod: 'per_unit' })).toEqual({ model: 'per_unit', source: 'table' })
+  })
+
+  it('legacy tiered → table / tiered', () => {
+    expect(normalizeChargePricing({ pricingMethod: 'tiered' })).toEqual({ model: 'tiered', source: 'table' })
+  })
+
+  it('legacy fixed → fixed / flat', () => {
+    expect(normalizeChargePricing({ pricingMethod: 'fixed' })).toEqual({ model: 'flat', source: 'fixed' })
+  })
+
+  it('new split: chargeModel=volume + pricingMethod=table → table / volume', () => {
+    expect(normalizeChargePricing({ chargeModel: 'volume', pricingMethod: 'table' })).toEqual({ model: 'volume', source: 'table' })
+  })
+
+  it('new split: chargeModel=per_unit + pricingMethod=fixed → fixed / per_unit', () => {
+    expect(normalizeChargePricing({ chargeModel: 'per_unit', pricingMethod: 'fixed' })).toEqual({ model: 'per_unit', source: 'fixed' })
+  })
+
+  it('explicit chargeModel wins over a legacy pricingMethod value', () => {
+    expect(normalizeChargePricing({ chargeModel: 'volume', pricingMethod: 'tiered' })).toEqual({ model: 'volume', source: 'table' })
+  })
+
+  it('chargeModel only (no pricingMethod), pricingTableId set → table / <model>', () => {
+    expect(normalizeChargePricing({ chargeModel: 'volume', pricingTableId: 't1' })).toEqual({ model: 'volume', source: 'table' })
+  })
+
+  it('all empty / null → fixed / flat (default)', () => {
+    expect(normalizeChargePricing({})).toEqual({ model: 'flat', source: 'fixed' })
+    expect(normalizeChargePricing({ chargeModel: null, pricingMethod: null })).toEqual({ model: 'flat', source: 'fixed' })
+  })
+
+  it('is case-insensitive on both axes', () => {
+    expect(normalizeChargePricing({ chargeModel: 'TIERED', pricingMethod: 'TABLE' })).toEqual({ model: 'tiered', source: 'table' })
+  })
+})