┌─────────────────────────────────────────────────────────────────────────────┐
│                      SERVICE SPECTRUM                                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   AUDIT ────► PACKAGE ────► RETAINER ────► ENTERPRISE                       │
│   $1.5K        $3-15K        $2.5K+/mo       Custom                          │
│                                                                              │
│   Discovery   Fixed scope   Ongoing         Dedicated team                   │
│   1 week      2-6 weeks     Monthly         + strategic                      │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

-- Automation package catalog
CREATE TABLE agency_packages (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  canonical_id text UNIQUE,
  
  -- Identity
  name text NOT NULL,
  slug text UNIQUE NOT NULL,
  tagline text,
  description text,
  
  -- Categorization
  tier text NOT NULL,  -- 'starter', 'growth', 'scale'
  category text NOT NULL,  -- 'content', 'sales', 'operations', 'video'
  
  -- Pricing
  base_price numeric NOT NULL,
  price_display text,  -- '$3,500' for display
  
  -- Timeline
  estimated_weeks integer,
  
  -- What's included (JSON)
  includes jsonb DEFAULT '[]',
  deliverables jsonb DEFAULT '[]',
  
  -- Marketing
  best_for text,
  icon text,
  
  -- Status
  is_active boolean DEFAULT true,
  display_order integer,
  
  created_at timestamptz DEFAULT now(),
  updated_at timestamptz DEFAULT now()
);

-- Package add-ons
CREATE TABLE agency_package_addons (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  
  name text NOT NULL,
  description text,
  price numeric NOT NULL,
  price_type text NOT NULL,  -- 'fixed', 'percentage', 'hourly', 'monthly'
  
  -- Which packages this applies to
  applicable_packages uuid[] DEFAULT '{}',  -- Empty = all packages
  
  is_active boolean DEFAULT true,
  created_at timestamptz DEFAULT now()
);

-- Purchased packages (links to projects)
CREATE TABLE agency_package_purchases (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  
  package_id uuid REFERENCES agency_packages(id),
  client_id uuid REFERENCES agency_clients(id),
  project_id uuid REFERENCES agency_projects(id),
  
  -- Pricing at time of purchase
  base_price numeric NOT NULL,
  addons_price numeric DEFAULT 0,
  total_price numeric NOT NULL,
  
  -- Add-ons selected
  selected_addons jsonb DEFAULT '[]',
  
  -- Customizations
  custom_requirements text,
  
  -- Status
  status text DEFAULT 'pending',  -- 'pending', 'active', 'completed', 'cancelled'
  
  purchased_at timestamptz DEFAULT now(),
  started_at timestamptz,
  completed_at timestamptz
);

-- Insert package catalog
INSERT INTO agency_packages (canonical_id, name, slug, tier, category, base_price, price_display, estimated_weeks, tagline, best_for, includes, deliverables) VALUES
(
  'pkg_content_starter',
  'Content Engine Starter',
  'content-engine-starter',
  'starter',
  'content',
  3500,
  '$3,500',
  2,
  'Launch your content machine',
  'Solopreneurs, small teams starting content',
  '[
    {"item": "Content calendar automation", "detail": "Notion/Airtable → scheduled posts"},
    {"item": "1 social platform integration", "detail": "Buffer/Later connection"},
    {"item": "AI writing workflow", "detail": "Blog post generation from briefs"},
    {"item": "30-day support", "detail": "Bug fixes + questions"}
  ]',
  '[
    "n8n workflow (webhook → AI → scheduling)",
    "Content calendar template",
    "Prompt library (5 templates)",
    "Video walkthrough"
  ]'
),
(
  'pkg_lead_capture',
  'Lead Capture Starter',
  'lead-capture-starter',
  'starter',
  'sales',
  4000,
  '$4,000',
  2,
  'Never miss a lead again',
  'Service businesses, consultants',
  '[
    {"item": "Form → CRM automation", "detail": "Typeform/Tally → HubSpot/Notion"},
    {"item": "Auto-responder sequence", "detail": "3-email welcome series"},
    {"item": "Lead scoring setup", "detail": "Basic qualification rules"},
    {"item": "Slack notifications", "detail": "New lead alerts"}
  ]',
  '[
    "Form configuration",
    "Email templates (3)",
    "n8n workflow",
    "Lead scoring rules doc"
  ]'
),
(
  'pkg_ai_agent',
  'AI Agent Deployment',
  'ai-agent-deployment',
  'scale',
  'operations',
  15000,
  '$15,000',
  6,
  'Your AI employee, deployed',
  'Operations teams ready for AI',
  '[
    {"item": "Custom AI agent", "detail": "Purpose-built for your workflow"},
    {"item": "Tool integrations", "detail": "Up to 10 tools"},
    {"item": "Training data setup", "detail": "Knowledge base configuration"},
    {"item": "Human-in-the-loop", "detail": "Approval workflows"},
    {"item": "60-day optimization", "detail": "Performance tuning"}
  ]',
  '[
    "Deployed AI agent",
    "Integration configurations",
    "Knowledge base",
    "Monitoring dashboard",
    "Runbook documentation",
    "Training (4 hours)"
  ]'
);

┌─────────────────────────────────────────────────────────────────┐
│                   PACKAGE SALES FLOW                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   BROWSE ──► CONFIGURE ──► CHECKOUT ──► KICKOFF                 │
│                                                                  │
│   Catalog    Add-ons       Payment      Onboarding              │
│   Filter     Custom        Deposit      Project                 │
│   Compare    Requirements  Invoice      Created                 │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Sync package to Shopify
async function syncPackageToShopify(packageId: string) {
  const pkg = await supabase
    .from('agency_packages')
    .select('*')
    .eq('id', packageId)
    .single();
  
  const shopifyProduct = {
    title: pkg.name,
    body_html: pkg.description,
    vendor: 'Trending Society Agency',
    product_type: 'Service',
    tags: [pkg.tier, pkg.category, 'automation-package'],
    variants: [{
      price: pkg.base_price.toString(),
      requires_shipping: false,
      taxable: true,
      inventory_management: null,  // Services don't track inventory
      fulfillment_service: 'manual'
    }],
    metafields: [
      { namespace: 'agency', key: 'package_id', value: pkg.id },
      { namespace: 'agency', key: 'estimated_weeks', value: pkg.estimated_weeks.toString() },
      { namespace: 'agency', key: 'includes', value: JSON.stringify(pkg.includes) }
    ]
  };
  
  // Create or update in Shopify
  return await shopify.product.create(shopifyProduct);
}

// Webhook: Shopify order created
async function handlePackagePurchase(order: ShopifyOrder) {
  // Extract package info from line item metafields
  const packageLineItem = order.line_items.find(
    item => item.product_type === 'Service'
  );
  
  const packageId = packageLineItem.properties.find(
    p => p.name === 'package_id'
  )?.value;
  
  // Create client if new
  const client = await findOrCreateClient({
    email: order.customer.email,
    company_name: order.billing_address?.company || order.customer.default_address?.company,
    contact_name: `${order.customer.first_name} ${order.customer.last_name}`
  });
  
  // Create project
  const project = await supabase
    .from('agency_projects')
    .insert({
      canonical_id: `proj_${order.order_number}`,
      client_id: client.id,
      name: `${packageLineItem.title} - ${order.order_number}`,
      budget: parseFloat(packageLineItem.price),
      status: 'active',
      start_date: new Date().toISOString()
    })
    .select()
    .single();
  
  // Record purchase
  await supabase
    .from('agency_package_purchases')
    .insert({
      package_id: packageId,
      client_id: client.id,
      project_id: project.data.id,
      base_price: parseFloat(packageLineItem.price),
      total_price: parseFloat(packageLineItem.price),
      status: 'active',
      started_at: new Date().toISOString()
    });
  
  // Create deliverables from package template
  await createPackageDeliverables(project.data.id, packageId);
  
  // Notify team
  await notifySlack(`🎉 New package purchase: ${packageLineItem.title} from ${client.company_name}`);
  
  // Send kickoff email
  await sendKickoffEmail(client, project.data);
}

## Package Kickoff Checklist

### Day 0: Order Received
- [ ] Project created in system
- [ ] Deliverables templated
- [ ] PM assigned
- [ ] Kickoff call scheduled

### Day 1-2: Kickoff Call
- [ ] Introductions
- [ ] Scope confirmation
- [ ] Timeline walkthrough
- [ ] Tool access requested
- [ ] Communication channel set up

### Day 3-5: Setup
- [ ] All credentials received
- [ ] Environments configured
- [ ] First milestone started
- [ ] Client updated on progress

interface PackageMilestone {
  name: string;
  week: number;
  deliverables: string[];
  client_touchpoint: 'call' | 'async' | 'none';
}

const contentStarterMilestones: PackageMilestone[] = [
  {
    name: 'Setup & Configuration',
    week: 1,
    deliverables: ['Calendar template', 'Tool connections'],
    client_touchpoint: 'call'
  },
  {
    name: 'Automation Build',
    week: 1.5,
    deliverables: ['n8n workflow', 'AI prompts'],
    client_touchpoint: 'async'
  },
  {
    name: 'Testing & Launch',
    week: 2,
    deliverables: ['Documentation', 'Training video'],
    client_touchpoint: 'call'
  }
];

Per Package:
├── Labor (25-35%)
│   └── PM time + execution
├── Tools (5-10%)
│   └── AI API costs, temp subscriptions
├── Overhead (10%)
│   └── Systems, support infrastructure
└── Margin (50-60%)
    └── Profit + reinvestment

Package Purchase
    ↓
Successful Delivery
    ↓
├── Extended Support (+$1K/mo)
├── Additional Package (cross-sell)
├── Retainer Proposal (managed service)
└── Enterprise Discussion (if growing)

-- Package sales summary
SELECT 
  p.name as package_name,
  p.tier,
  COUNT(pp.id) as times_sold,
  SUM(pp.total_price) as total_revenue,
  AVG(pp.total_price) as avg_sale_price,
  AVG(EXTRACT(days FROM (pp.completed_at - pp.started_at))) as avg_delivery_days
FROM agency_packages p
LEFT JOIN agency_package_purchases pp ON p.id = pp.package_id
GROUP BY p.id
ORDER BY total_revenue DESC;

-- Conversion: package → retainer
SELECT 
  p.name as package_name,
  COUNT(pp.id) as package_sales,
  COUNT(r.id) as converted_to_retainer,
  ROUND(COUNT(r.id)::numeric / NULLIF(COUNT(pp.id), 0) * 100, 1) as conversion_rate
FROM agency_packages p
JOIN agency_package_purchases pp ON p.id = pp.package_id
LEFT JOIN agency_retainers r ON pp.client_id = r.client_id 
  AND r.created_at > pp.completed_at
GROUP BY p.id;

-- Most popular add-ons
SELECT 
  addon->>'name' as addon_name,
  COUNT(*) as times_selected,
  SUM((addon->>'price')::numeric) as addon_revenue
FROM agency_package_purchases pp,
  jsonb_array_elements(pp.selected_addons) as addon
GROUP BY addon->>'name'
ORDER BY times_selected DESC;

/services                    # All packages
/services/content            # Content packages
/services/sales              # Sales packages
/services/content-engine     # Specific package

interface PackagePageProps {
  package: AgencyPackage;
  addons: AgencyPackageAddon[];
  testimonials: Testimonial[];
}

function PackagePage({ package: pkg, addons, testimonials }: PackagePageProps) {
  return (
    <div>
      {/* Hero */}
      <section>
        <span className="badge">{pkg.tier}</span>
        <h1>{pkg.name}</h1>
        <p>{pkg.tagline}</p>
        <div className="price">
          <span className="amount">{pkg.price_display}</span>
          <span className="timeline">{pkg.estimated_weeks} weeks</span>
        </div>
        <Button>Get Started</Button>
      </section>
      
      {/* What's Included */}
      <section>
        <h2>What's Included</h2>
        <ul>
          {pkg.includes.map(item => (
            <li key={item.item}>
              <strong>{item.item}</strong>
              <span>{item.detail}</span>
            </li>
          ))}
        </ul>
      </section>
      
      {/* Deliverables */}
      <section>
        <h2>You'll Receive</h2>
        <ul>
          {pkg.deliverables.map(d => <li key={d}>{d}</li>)}
        </ul>
      </section>
      
      {/* Add-ons */}
      <section>
        <h2>Customize Your Package</h2>
        <AddonSelector addons={addons} />
      </section>
      
      {/* Social Proof */}
      <section>
        <h2>Results From This Package</h2>
        <Testimonials items={testimonials} />
      </section>
      
      {/* CTA */}
      <section>
        <h2>Ready to Automate?</h2>
        <PurchaseForm package={pkg} />
      </section>
    </div>
  );
}