<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>GB | GC Command Center</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap" rel="stylesheet">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js"></script>
<style>
/* ==================== RESET & BASE ==================== */
*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
:root{
  --bg:#0F1117;--card:#1A1D27;--border:#2A2D37;--text:#E5E7EB;--text2:#9CA3AF;
  --accent:#2D6A2D;--accent-light:#3a8a3a;--success:#22C55E;--warn:#F59E0B;--danger:#EF4444;
  --sidebar-w:260px;--sidebar-collapsed:68px;--radius:8px;--shadow:0 2px 8px rgba(0,0,0,.3);
}
html,body{height:100%;font-family:'DM Sans',sans-serif;background:var(--bg);color:var(--text);font-size:14px;line-height:1.5}
a{color:var(--accent-light);text-decoration:none}
button{font-family:inherit;cursor:pointer;border:none;font-size:14px}
input,select,textarea{font-family:inherit;font-size:14px;background:#252830;color:var(--text);border:1px solid var(--border);border-radius:var(--radius);padding:8px 12px;outline:none;width:100%}
input:focus,select:focus,textarea:focus{border-color:var(--accent)}
textarea{resize:vertical;min-height:80px}
select{cursor:pointer}
table{width:100%;border-collapse:collapse}
th,td{text-align:left;padding:10px 12px;border-bottom:1px solid var(--border)}
th{color:var(--text2);font-weight:600;font-size:13px;text-transform:uppercase;letter-spacing:.5px}
tr:hover{background:rgba(45,106,45,.05)}
::-webkit-scrollbar{width:8px;height:8px}
::-webkit-scrollbar-track{background:var(--bg)}
::-webkit-scrollbar-thumb{background:var(--border);border-radius:4px}
::-webkit-scrollbar-thumb:hover{background:#444}

/* ==================== LOGIN ==================== */
#login-screen{position:fixed;inset:0;z-index:9999;background:var(--bg);display:flex;align-items:center;justify-content:center}
.login-box{background:var(--card);border:1px solid var(--border);border-radius:12px;padding:48px 40px;width:380px;text-align:center;box-shadow:var(--shadow)}
.login-box h1{color:var(--accent-light);font-size:28px;margin-bottom:4px}
.login-box p{color:var(--text2);margin-bottom:24px}
.login-box input{margin-bottom:16px}
.login-box .error{color:var(--danger);font-size:13px;margin-bottom:8px;display:none}

/* ==================== BUTTONS ==================== */
.btn{display:inline-flex;align-items:center;gap:6px;padding:8px 16px;border-radius:var(--radius);font-weight:500;transition:all .2s}
.btn-primary{background:var(--accent);color:#fff}.btn-primary:hover{background:var(--accent-light)}
.btn-secondary{background:var(--border);color:var(--text)}.btn-secondary:hover{background:#3a3d47}
.btn-danger{background:var(--danger);color:#fff}.btn-danger:hover{background:#dc2626}
.btn-warn{background:var(--warn);color:#000}.btn-warn:hover{background:#d97706}
.btn-success{background:var(--success);color:#000}.btn-success:hover{background:#16a34a}
.btn-sm{padding:5px 10px;font-size:12px}
.btn-ghost{background:transparent;color:var(--text2);border:1px solid var(--border)}.btn-ghost:hover{border-color:var(--accent);color:var(--text)}
.btn-icon{width:32px;height:32px;padding:0;display:inline-flex;align-items:center;justify-content:center;border-radius:var(--radius);background:transparent;color:var(--text2)}.btn-icon:hover{background:var(--border)}

/* ==================== LAYOUT ==================== */
#app{display:none;height:100vh;overflow:hidden}
#sidebar{position:fixed;left:0;top:0;bottom:0;width:var(--sidebar-w);background:var(--card);border-right:1px solid var(--border);display:flex;flex-direction:column;transition:width .3s;z-index:100;overflow:hidden}
#sidebar.collapsed{width:var(--sidebar-collapsed)}
.sidebar-header{padding:16px;display:flex;align-items:center;gap:12px;border-bottom:1px solid var(--border);min-height:64px}
.sidebar-header .logo{width:36px;height:36px;background:var(--accent);border-radius:8px;display:flex;align-items:center;justify-content:center;font-weight:700;color:#fff;font-size:14px;flex-shrink:0}
.sidebar-header .brand{font-weight:700;font-size:15px;white-space:nowrap;overflow:hidden}
.sidebar-header .brand span{color:var(--accent-light)}
#sidebar.collapsed .brand{display:none}
.sidebar-nav{flex:1;overflow-y:auto;padding:8px}
.nav-item{display:flex;align-items:center;gap:12px;padding:10px 12px;border-radius:var(--radius);color:var(--text2);cursor:pointer;transition:all .15s;white-space:nowrap;overflow:hidden;margin-bottom:2px}
.nav-item:hover{background:rgba(45,106,45,.15);color:var(--text)}
.nav-item.active{background:rgba(45,106,45,.2);color:var(--accent-light)}
.nav-item i{width:20px;text-align:center;flex-shrink:0;font-size:16px}
#sidebar.collapsed .nav-label{display:none}
.sidebar-footer{padding:12px;border-top:1px solid var(--border);display:flex;gap:8px;flex-wrap:wrap}
.sidebar-footer .btn{font-size:12px;flex:1}
#sidebar.collapsed .sidebar-footer .btn span{display:none}
#toggle-sidebar{position:absolute;right:-14px;top:72px;width:28px;height:28px;background:var(--card);border:1px solid var(--border);border-radius:50%;display:flex;align-items:center;justify-content:center;cursor:pointer;color:var(--text2);z-index:101;font-size:12px;transition:transform .3s}
#sidebar.collapsed #toggle-sidebar{transform:rotate(180deg)}

#main{margin-left:var(--sidebar-w);height:100vh;overflow-y:auto;transition:margin-left .3s;padding:24px}
#sidebar.collapsed~#main{margin-left:var(--sidebar-collapsed)}

/* ==================== CARDS & GRID ==================== */
.grid{display:grid;gap:20px}
.grid-2{grid-template-columns:repeat(2,1fr)}
.grid-3{grid-template-columns:repeat(3,1fr)}
.grid-4{grid-template-columns:repeat(4,1fr)}
.grid-6{grid-template-columns:repeat(6,1fr)}
@media(max-width:1200px){.grid-4,.grid-6{grid-template-columns:repeat(3,1fr)}}
@media(max-width:900px){.grid-2,.grid-3,.grid-4,.grid-6{grid-template-columns:repeat(2,1fr)}}
@media(max-width:600px){.grid-2,.grid-3,.grid-4,.grid-6{grid-template-columns:1fr}}
.card{background:var(--card);border:1px solid var(--border);border-radius:var(--radius);padding:20px;box-shadow:var(--shadow)}
.card-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px}
.card-title{font-weight:600;font-size:16px}
.kpi-card{text-align:center;padding:20px}
.kpi-card .kpi-icon{font-size:24px;color:var(--accent-light);margin-bottom:8px}
.kpi-card .kpi-value{font-size:28px;font-weight:700}
.kpi-card .kpi-label{color:var(--text2);font-size:13px;margin-top:4px}
.kpi-card .kpi-trend{font-size:12px;margin-top:4px}
.kpi-trend.up{color:var(--success)}.kpi-trend.down{color:var(--danger)}

/* ==================== MODAL ==================== */
.modal-overlay{position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:1000;display:flex;align-items:center;justify-content:center;opacity:0;pointer-events:none;transition:opacity .2s}
.modal-overlay.active{opacity:1;pointer-events:all}
.modal{background:var(--card);border:1px solid var(--border);border-radius:12px;width:90%;max-width:700px;max-height:85vh;overflow-y:auto;box-shadow:0 8px 32px rgba(0,0,0,.5);padding:24px}
.modal-lg{max-width:900px}
.modal-xl{max-width:1100px}
.modal h2{font-size:20px;margin-bottom:16px;display:flex;align-items:center;gap:8px}
.modal-close{position:absolute;top:16px;right:16px;font-size:20px;color:var(--text2);cursor:pointer;background:none;border:none}
.form-row{display:grid;grid-template-columns:repeat(2,1fr);gap:12px;margin-bottom:12px}
.form-group{margin-bottom:12px}
.form-group label{display:block;font-size:13px;color:var(--text2);margin-bottom:4px;font-weight:500}
.form-actions{display:flex;gap:8px;justify-content:flex-end;margin-top:16px;padding-top:16px;border-top:1px solid var(--border)}

/* ==================== TOAST ==================== */
#toast-container{position:fixed;top:20px;right:20px;z-index:9999;display:flex;flex-direction:column;gap:8px}
.toast{padding:12px 20px;border-radius:var(--radius);color:#fff;font-weight:500;animation:slideIn .3s;min-width:250px;display:flex;align-items:center;gap:8px;box-shadow:var(--shadow)}
.toast-success{background:#166534}.toast-error{background:#991b1b}.toast-info{background:#1e3a5f}
@keyframes slideIn{from{transform:translateX(100%);opacity:0}to{transform:translateX(0);opacity:1}}

/* ==================== TABS ==================== */
.tabs{display:flex;gap:4px;border-bottom:1px solid var(--border);margin-bottom:16px}
.tab{padding:8px 16px;color:var(--text2);cursor:pointer;border-bottom:2px solid transparent;transition:all .15s;font-weight:500}
.tab:hover{color:var(--text)}.tab.active{color:var(--accent-light);border-bottom-color:var(--accent)}

/* ==================== BADGES & STATUS ==================== */
.badge{display:inline-block;padding:2px 8px;border-radius:12px;font-size:11px;font-weight:600}
.badge-new{background:rgba(34,197,94,.15);color:var(--success)}
.badge-contacted{background:rgba(59,130,246,.15);color:#3b82f6}
.badge-quoted{background:rgba(245,158,11,.15);color:var(--warn)}
.badge-won{background:rgba(45,106,45,.2);color:var(--accent-light)}
.badge-lost{background:rgba(239,68,68,.15);color:var(--danger)}
.status-dot{width:8px;height:8px;border-radius:50%;display:inline-block}
.status-online{background:var(--success)}.status-offline{background:var(--danger)}.status-warning{background:var(--warn)}

/* ==================== KANBAN ==================== */
.kanban{display:flex;gap:16px;overflow-x:auto;padding-bottom:8px}
.kanban-col{min-width:220px;flex:1;background:rgba(0,0,0,.2);border-radius:var(--radius);padding:12px}
.kanban-col-title{font-weight:600;font-size:13px;text-transform:uppercase;letter-spacing:.5px;color:var(--text2);margin-bottom:12px;display:flex;align-items:center;gap:6px}
.kanban-col-title .count{background:var(--border);border-radius:10px;padding:1px 8px;font-size:11px}
.kanban-card{background:var(--card);border:1px solid var(--border);border-radius:6px;padding:10px;margin-bottom:8px;cursor:pointer;transition:border-color .15s}
.kanban-card:hover{border-color:var(--accent)}
.kanban-card .card-brand{font-size:11px;font-weight:600;margin-bottom:4px}
.kanban-card .card-brand.gb{color:var(--accent-light)}.kanban-card .card-brand.gc{color:#3b82f6}

/* ==================== CALENDAR ==================== */
.cal-week{display:grid;grid-template-columns:repeat(7,1fr);gap:8px}
.cal-day{background:rgba(0,0,0,.15);border-radius:6px;padding:8px;min-height:120px}
.cal-day-header{font-size:11px;font-weight:600;color:var(--text2);text-transform:uppercase;margin-bottom:8px}
.cal-event{font-size:11px;padding:4px 6px;border-radius:4px;margin-bottom:4px;border-left:3px solid}
.cal-platform-row{padding:2px 0}
.nav-badge{background:var(--danger);color:#fff;font-size:10px;font-weight:700;border-radius:10px;padding:1px 6px;margin-left:auto;min-width:18px;text-align:center;line-height:16px}
.infra-budget-banner{background:rgba(239,68,68,.15);border:1px solid var(--danger);border-radius:var(--radius);padding:12px 16px;margin-bottom:16px;display:flex;align-items:center;gap:10px;color:var(--danger);font-weight:500}
.infra-budget-banner i{font-size:18px}
.infra-monthly-total{background:rgba(245,158,11,.1);border:1px solid rgba(245,158,11,.3);border-radius:var(--radius);padding:16px;text-align:center}
.infra-monthly-total .total-value{font-size:32px;font-weight:700;color:var(--warn)}
.infra-monthly-total .projected{font-size:13px;color:var(--text2);margin-top:4px}
.error-search-input{max-width:300px;margin-bottom:12px}
.sort-btn{cursor:pointer;user-select:none}.sort-btn:hover{color:var(--text)}

/* ==================== SECTION ==================== */
.module{display:none}
.module.active{display:block}
.module-header{margin-bottom:20px}
.module-header h1{font-size:24px;font-weight:700;margin-bottom:4px}
.module-header p{color:var(--text2)}
.section{margin-bottom:24px}
.section-title{font-size:16px;font-weight:600;margin-bottom:12px;display:flex;align-items:center;gap:8px}
.toolbar{display:flex;align-items:center;gap:8px;margin-bottom:16px;flex-wrap:wrap}
.toolbar input,.toolbar select{width:auto;min-width:140px}
.search-input{position:relative}
.search-input input{padding-left:32px}
.search-input i{position:absolute;left:10px;top:50%;transform:translateY(-50%);color:var(--text2)}

/* ==================== AI CHAT ==================== */
#ai-chat-btn{position:fixed;bottom:24px;right:24px;width:56px;height:56px;border-radius:50%;background:var(--accent);color:#fff;font-size:22px;display:flex;align-items:center;justify-content:center;box-shadow:0 4px 16px rgba(45,106,45,.4);z-index:500;transition:transform .2s}
#ai-chat-btn:hover{transform:scale(1.1)}
#ai-chat-panel{position:fixed;bottom:90px;right:24px;width:420px;max-height:600px;background:var(--card);border:1px solid var(--border);border-radius:12px;box-shadow:0 8px 32px rgba(0,0,0,.5);z-index:500;display:none;flex-direction:column;overflow:hidden}
#ai-chat-panel.open{display:flex}
.chat-header{padding:16px;border-bottom:1px solid var(--border);display:flex;align-items:center;justify-content:space-between}
.chat-header h3{font-size:16px}
.chat-messages{flex:1;overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:12px;max-height:380px}
.chat-msg{padding:10px 14px;border-radius:10px;max-width:85%;font-size:13px;line-height:1.5}
.chat-msg.user{background:var(--accent);color:#fff;align-self:flex-end;border-bottom-right-radius:2px}
.chat-msg.ai{background:#252830;color:var(--text);align-self:flex-start;border-bottom-left-radius:2px}
.chat-msg.ai pre{background:#1a1d22;padding:8px;border-radius:4px;overflow-x:auto;margin:4px 0;font-size:12px}
.chat-quick-actions{padding:8px 16px;display:flex;flex-wrap:wrap;gap:4px;border-bottom:1px solid var(--border)}
.chat-quick-actions button{font-size:11px;padding:4px 8px;border-radius:12px;background:rgba(45,106,45,.2);color:var(--accent-light);border:1px solid rgba(45,106,45,.3);cursor:pointer}
.chat-quick-actions button:hover{background:rgba(45,106,45,.3)}
.chat-input-area{padding:12px 16px;border-top:1px solid var(--border);display:flex;gap:8px}
.chat-input-area input{flex:1}
.chat-input-area button{flex-shrink:0}

/* ==================== LOADING / SPINNER ==================== */
.spinner{display:inline-block;width:20px;height:20px;border:2px solid var(--border);border-top-color:var(--accent-light);border-radius:50%;animation:spin .6s linear infinite}
@keyframes spin{to{transform:rotate(360deg)}}
.loading-overlay{position:absolute;inset:0;background:rgba(15,17,23,.8);display:flex;align-items:center;justify-content:center;flex-direction:column;gap:12px;border-radius:var(--radius);z-index:10;color:var(--text2)}

/* ==================== SEASONAL CALENDAR ==================== */
.season-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:12px}
.season-month{background:rgba(0,0,0,.2);border-radius:var(--radius);padding:12px}
.season-month h4{font-size:13px;font-weight:600;margin-bottom:8px;color:var(--accent-light)}
.season-tag{display:inline-block;padding:2px 6px;border-radius:4px;font-size:11px;margin:2px;background:rgba(45,106,45,.15);color:var(--accent-light)}
.season-tag.peak{background:rgba(239,68,68,.15);color:var(--danger)}

/* ==================== CHECKLIST ==================== */
.checklist-item{display:flex;align-items:center;gap:10px;padding:8px 0;border-bottom:1px solid rgba(42,45,55,.5)}
.checklist-item input[type=checkbox]{width:18px;height:18px;accent-color:var(--accent)}
.checklist-item.checked label{text-decoration:line-through;color:var(--text2)}

/* ==================== MISC ==================== */
.empty-state{text-align:center;padding:40px;color:var(--text2)}
.empty-state i{font-size:40px;margin-bottom:12px;opacity:.5}

/* ==================== AI GENERATED CONTENT ==================== */
.ai-content{background:rgba(45,106,45,.05);border:1px solid rgba(45,106,45,.2);border-radius:var(--radius);padding:16px;margin:8px 0;position:relative}
.ai-content::before{content:'AI Generated';position:absolute;top:-8px;left:12px;background:var(--card);padding:0 6px;font-size:10px;color:var(--accent-light);font-weight:600;letter-spacing:.5px;text-transform:uppercase}
.ai-content pre{background:#1a1d22;padding:8px;border-radius:4px;overflow-x:auto;font-size:12px;margin:4px 0}

/* ==================== ENHANCED TABLE SORT ==================== */
th[onclick]{cursor:pointer;user-select:none;transition:color .15s}
th[onclick]:hover{color:var(--accent-light)}

/* ==================== PLATFORM COLORS ==================== */
.platform-fb{color:#1877F2}.platform-ig{color:#E4405F}.platform-x{color:#1DA1F2}
.platform-tt{color:#000}.platform-nd{color:#8ED500}.platform-gbp{color:#4285F4}

/* ==================== FUNNEL ==================== */
.funnel-bar{padding:12px 16px;border-radius:6px;text-align:center;font-weight:600;transition:all .3s;position:relative;margin-bottom:4px}
.funnel-bar .funnel-val{font-size:20px;font-weight:700}
.funnel-bar .funnel-label{font-size:12px;opacity:.8}
.funnel-conv{font-size:11px;color:var(--text2);text-align:center;padding:2px 0}

/* ==================== HEAT MAP ==================== */
.heat-grid{display:grid;gap:1px;font-size:10px}
.heat-cell{padding:4px;text-align:center;border-radius:2px;font-weight:600;min-height:28px;display:flex;align-items:center;justify-content:center}
.heat-header{font-weight:700;color:var(--text2);font-size:10px;text-transform:uppercase}

/* ==================== NAV BADGE ==================== */
.nav-badge{background:var(--danger);color:#fff;border-radius:10px;padding:1px 6px;font-size:10px;font-weight:700;margin-left:auto}
.divider{border:none;border-top:1px solid var(--border);margin:16px 0}
.flex{display:flex}.flex-between{display:flex;align-items:center;justify-content:space-between}
.gap-8{gap:8px}.gap-12{gap:12px}.gap-16{gap:16px}
.mt-8{margin-top:8px}.mt-16{margin-top:16px}.mt-24{margin-top:24px}
.mb-8{margin-bottom:8px}.mb-16{margin-bottom:16px}
.text-sm{font-size:13px}.text-xs{font-size:11px}
.text-muted{color:var(--text2)}
.text-success{color:var(--success)}.text-danger{color:var(--danger)}.text-warn{color:var(--warn)}
.w-full{width:100%}
.overflow-auto{overflow:auto}
.relative{position:relative}
.hidden{display:none!important}
</style>
</head>
<body>

<!-- ==================== LOGIN SCREEN ==================== -->
<div id="login-screen">
  <div class="login-box">
    <div style="font-size:48px;margin-bottom:12px">&#x1f41b;&#x1f9f9;</div>
    <h1>GB | GC</h1>
    <p>AI Business Command Center</p>
    <div class="error" id="login-error">Incorrect password. Try again.</div>
    <input type="password" id="login-pw" placeholder="Enter password..." autofocus>
    <button class="btn btn-primary w-full" onclick="attemptLogin()" style="margin-top:4px"><i class="fas fa-lock"></i> Sign In</button>
  </div>
</div>

<!-- ==================== MAIN APP ==================== -->
<div id="app">
  <!-- SIDEBAR -->
  <nav id="sidebar">
    <div id="toggle-sidebar" onclick="toggleSidebar()"><i class="fas fa-chevron-left"></i></div>
    <div class="sidebar-header">
      <div class="logo">GB</div>
      <div class="brand">GB | <span>GC</span> Center</div>
    </div>
    <div class="sidebar-nav" id="sidebar-nav"></div>
    <div class="sidebar-footer">
      <button class="btn btn-ghost btn-sm" onclick="exportData()" title="Export Data"><i class="fas fa-download"></i> <span>Export</span></button>
      <button class="btn btn-ghost btn-sm" onclick="document.getElementById('import-file').click()" title="Import Data"><i class="fas fa-upload"></i> <span>Import</span></button>
      <input type="file" id="import-file" accept=".json" style="display:none" onchange="importData(event)">
      <button class="btn btn-ghost btn-sm" onclick="logout()" title="Logout"><i class="fas fa-sign-out-alt"></i> <span>Logout</span></button>
    </div>
  </nav>

  <!-- MAIN CONTENT -->
  <div id="main"></div>
</div>

<!-- ==================== AI CHAT FLOATING ==================== -->
<button id="ai-chat-btn" onclick="toggleChat()" style="display:none"><i class="fas fa-robot"></i></button>
<div id="ai-chat-panel">
  <div class="chat-header">
    <h3><i class="fas fa-robot" style="color:var(--accent-light)"></i> AI Advisor</h3>
    <button class="btn-icon" onclick="toggleChat()"><i class="fas fa-times"></i></button>
  </div>
  <div class="chat-quick-actions">
    <button onclick="quickChat('Give me a weekly strategy brief based on my current dashboard data')">Weekly Brief</button>
    <button onclick="quickChat('What should I post on social media today? Check my content calendar and seasonal data.')">Post Today</button>
    <button onclick="quickChat('Analyze my current leads pipeline and give specific recommendations')">Analyze Leads</button>
    <button onclick="quickChat('Give me a revenue and financial health check with action items')">Revenue Check</button>
    <button onclick="quickChat('Generate 7 content ideas for this week based on seasonal data and recent gaps')">Content Ideas</button>
    <button onclick="quickChat('Write a professional email to a customer. Ask me for the details.')">Write Email</button>
    <button onclick="quickChat('Create a seasonal special offer based on current month pest activity')">Seasonal Offer</button>
    <button onclick="quickChat('Summarize my competitive positioning based on stored competitor data')">Competitor Check</button>
    <button onclick="quickChat('What areas of my business are underperforming and what should I fix first?')">Underperforming?</button>
    <button onclick="quickChat('Generate a 30-day action plan for both businesses')">30-Day Plan</button>
  </div>
  <div class="chat-messages" id="chat-messages"></div>
  <div class="chat-input-area">
    <input type="text" id="chat-input" placeholder="Ask your AI advisor..." onkeydown="if(event.key==='Enter')sendChat()">
    <button class="btn btn-primary" onclick="sendChat()"><i class="fas fa-paper-plane"></i></button>
  </div>
</div>

<!-- TOAST CONTAINER -->
<div id="toast-container"></div>

<!-- MODAL OVERLAY -->
<div class="modal-overlay" id="modal-overlay" onclick="if(event.target===this)closeModal()">
  <div class="modal" id="modal-content"></div>
</div>

<script>
// ==================== CONFIGURATION ====================
const CONFIG = {
  apiKey: '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',
  model: 'claude-sonnet-4-20250514',
  apiUrl: 'https://api.anthropic.com/v1/messages',
  maxTokens: 4096,
  password: 'greenbones2026',
  businesses: ['Green Bones Pest Control', 'Green Clean Disinfectants'],
  serviceAreas: ['Yuba City','Marysville','Plumas Lake','Linda','Olivehurst','Live Oak','Gridley','Wheatland','Beale AFB'],
  gbServices: ['General Pest','Ants','Spiders','Rodents','Mosquitoes','Bed Bugs','Termites','Wildlife','Commercial'],
  gcServices: ['Residential Disinfection','Commercial Disinfection','Mold Treatment','Biohazard','Move-in/Move-out','Other'],
  leadSources: ['Nextdoor','Facebook','Craigslist','Reddit','Yelp','Angi','Website','Referral','Google','TikTok','Other'],
  leadStatuses: ['New','Contacted','Estimate Scheduled','Quoted','Follow Up','Won','Lost'],
  platforms: ['Facebook','Instagram','X/Twitter','TikTok','Nextdoor','Google Business Profile']
};

const NAV_ITEMS = [
  {id:'dashboard',icon:'fa-gauge-high',label:'Command Center'},
  {id:'leads',icon:'fa-users',label:'Lead Pipeline & CRM'},
  {id:'seo',icon:'fa-search',label:'SEO Command Center'},
  {id:'social',icon:'fa-share-nodes',label:'Social Media'},
  {id:'video',icon:'fa-video',label:'Video & Ad Campaigns'},
  {id:'reviews',icon:'fa-star',label:'Reviews & Reputation'},
  {id:'competitors',icon:'fa-chess',label:'Competitor Intel'},
  {id:'seasonal',icon:'fa-calendar-days',label:'Seasonal Planner'},
  {id:'analytics',icon:'fa-chart-line',label:'Analytics & Finance'},
  {id:'infra',icon:'fa-server',label:'Infrastructure'},
  {id:'settings',icon:'fa-gear',label:'Settings'}
];

// ==================== DATA LAYER (localStorage) ====================
const DB = {
  get(key, def=null){ try{const v=localStorage.getItem('gbgc_'+key);return v?JSON.parse(v):def}catch(e){return def} },
  set(key, val){ localStorage.setItem('gbgc_'+key, JSON.stringify(val)) },
  remove(key){ localStorage.removeItem('gbgc_'+key) },
  keys(){ return Object.keys(localStorage).filter(k=>k.startsWith('gbgc_')).map(k=>k.slice(5)) },
  getAll(){
    const data={};
    Object.keys(localStorage).filter(k=>k.startsWith('gbgc_')).forEach(k=>{
      try{data[k.slice(5)]=JSON.parse(localStorage.getItem(k))}catch(e){data[k.slice(5)]=localStorage.getItem(k)}
    });
    return data;
  },
  setAll(data){ Object.entries(data).forEach(([k,v])=>localStorage.setItem('gbgc_'+k,JSON.stringify(v))) }
};

function getLeads(){ return DB.get('leads',[]) }
function saveLeads(l){ DB.set('leads',l) }
function getKeywords(){ return DB.get('keywords',[]) }
function saveKeywords(k){ DB.set('keywords',k) }
function getBlogPosts(){ return DB.get('blogPosts',[]) }
function saveBlogPosts(p){ DB.set('blogPosts',p) }
function getSocialPosts(){ return DB.get('socialPosts',[]) }
function saveSocialPosts(p){ DB.set('socialPosts',p) }
function getEngagement(){ return DB.get('engagement',[]) }
function saveEngagement(e){ DB.set('engagement',e) }
function getReviews(){ return DB.get('reviews',[]) }
function saveReviews(r){ DB.set('reviews',r) }
function getCompetitors(){ return DB.get('competitors',[]) }
function saveCompetitors(c){ DB.set('competitors',c) }
function getRevenue(){ return DB.get('revenue',[]) }
function saveRevenue(r){ DB.set('revenue',r) }
function getBacklinks(){ return DB.get('backlinks',[]) }
function saveBacklinks(b){ DB.set('backlinks',b) }
function getChecklist(biz){ return DB.get('checklist_'+biz,{}) }
function saveChecklist(biz,c){ DB.set('checklist_'+biz,c) }
function getCampaigns(){ return DB.get('campaigns',[]) }
function saveCampaigns(c){ DB.set('campaigns',c) }
function getAdPerf(){ return DB.get('adPerf',[]) }
function saveAdPerf(a){ DB.set('adPerf',a) }
function getErrors(){ return DB.get('errorLog',[]) }
function saveErrors(e){ DB.set('errorLog',e) }
function getApiCosts(){ return DB.get('apiCosts',[]) }
function saveApiCosts(c){ DB.set('apiCosts',c) }
function getAgents(){ return DB.get('agents',{winston:{status:'online',lastRun:'',leadsToday:0,errors:0},rachel:{status:'online',services:'Lead pipeline, X engagement',lastRestart:'',notes:''},imageAgent:{status:'online',lastImage:'',model:'Gemma4',notes:''}}) }
function saveAgents(a){ DB.set('agents',a) }
function getActivity(){ return DB.get('activity',[]) }
function addActivity(text,module){
  const act=getActivity();
  act.unshift({text,module,time:new Date().toISOString()});
  if(act.length>100)act.length=100;
  DB.set('activity',act);
}
function nextId(arr){ return arr.length?Math.max(...arr.map(a=>a.id||0))+1:1 }

// ==================== UI FRAMEWORK ====================
let currentModule = 'dashboard';
let chartInstances = {};
let calendarWeekOffset = 0;

function toggleSidebar(){
  document.getElementById('sidebar').classList.toggle('collapsed');
}

function navigateTo(id){
  currentModule=id;
  document.querySelectorAll('.nav-item').forEach(n=>n.classList.toggle('active',n.dataset.id===id));
  renderModule(id);
}

function renderSidebar(){
  const nav=document.getElementById('sidebar-nav');
  const openErrors=getErrors().filter(e=>(e.status||'Open')==='Open').length;
  nav.innerHTML=NAV_ITEMS.map(n=>{
    const badge=(n.id==='infra'&&openErrors>0)?`<span class="nav-badge">${openErrors}</span>`:'';
    return `<div class="nav-item" data-id="${n.id}" onclick="navigateTo('${n.id}')"><i class="fas ${n.icon}"></i><span class="nav-label">${n.label}</span>${badge}</div>`;
  }).join('');
}

function renderModule(id){
  const main=document.getElementById('main');
  destroyCharts();
  switch(id){
    case 'dashboard': renderDashboard(main); fetchWinstonData(); break;
    case 'leads': renderLeads(main); break;
    case 'seo': renderSEO(main); break;
    case 'social': renderSocial(main); break;
    case 'video': renderVideo(main); break;
    case 'reviews': renderReviews(main); break;
    case 'competitors': renderCompetitors(main); break;
    case 'seasonal': renderSeasonal(main); break;
    case 'analytics': renderAnalytics(main); break;
    case 'infra': renderInfra(main); break;
    case 'settings': renderSettings(main); break;
  }
}

function destroyCharts(){
  Object.values(chartInstances).forEach(c=>{try{c.destroy()}catch(e){}});
  chartInstances={};
}

function createChart(canvasId, config){
  const ctx=document.getElementById(canvasId);
  if(!ctx)return null;
  const c=new Chart(ctx,config);
  chartInstances[canvasId]=c;
  return c;
}

function showModal(html,cls=''){
  const overlay=document.getElementById('modal-overlay');
  const content=document.getElementById('modal-content');
  content.className='modal '+(cls||'');
  content.innerHTML=html;
  overlay.classList.add('active');
}

function closeModal(){
  document.getElementById('modal-overlay').classList.remove('active');
}

function toast(msg,type='success'){
  const c=document.getElementById('toast-container');
  const t=document.createElement('div');
  t.className='toast toast-'+type;
  t.innerHTML=`<i class="fas fa-${type==='success'?'check-circle':type==='error'?'exclamation-circle':'info-circle'}"></i> ${msg}`;
  c.appendChild(t);
  setTimeout(()=>t.remove(),3500);
}

function formatDate(d){
  if(!d)return '';
  const dt=new Date(d);
  return dt.toLocaleDateString('en-US',{month:'short',day:'numeric',year:'numeric'});
}

function daysSince(d){
  if(!d)return 0;
  return Math.floor((Date.now()-new Date(d).getTime())/(1000*60*60*24));
}

function statusBadge(s){
  const cls={'New':'new','Contacted':'contacted','Estimate Scheduled':'contacted','Quoted':'quoted','Follow Up':'quoted','Won':'won','Lost':'lost'};
  return `<span class="badge badge-${cls[s]||'new'}">${s}</span>`;
}

// ==================== AI INTEGRATION ====================
let chatHistory = []; // Conversation history for AI advisor

async function callClaude(systemPrompt, userMsg, onStream=null){
  const apiKey = CONFIG.apiKey || DB.get('apiKey','');
  if(!apiKey){toast('Set your API key in Settings first','error');return null}
  try{
    const res = await fetch(CONFIG.apiUrl, {
      method:'POST',
      headers:{
        'Content-Type':'application/json',
        'x-api-key':apiKey,
        'anthropic-version':'2023-06-01',
        'anthropic-dangerous-direct-browser-access':'true'
      },
      body:JSON.stringify({
        model:CONFIG.model,
        max_tokens:CONFIG.maxTokens,
        system:systemPrompt,
        messages:[{role:'user',content:userMsg}]
      })
    });
    if(!res.ok){const e=await res.text();throw new Error(e)}
    const data=await res.json();
    return data.content[0].text;
  }catch(e){
    console.error('Claude API error:',e);
    toast('AI request failed: '+e.message,'error');
    return null;
  }
}

async function callClaudeWithHistory(systemPrompt, messages){
  const apiKey = CONFIG.apiKey || DB.get('apiKey','');
  if(!apiKey){toast('Set your API key in Settings first','error');return null}
  try{
    const res = await fetch(CONFIG.apiUrl, {
      method:'POST',
      headers:{
        'Content-Type':'application/json',
        'x-api-key':apiKey,
        'anthropic-version':'2023-06-01',
        'anthropic-dangerous-direct-browser-access':'true'
      },
      body:JSON.stringify({
        model:CONFIG.model,
        max_tokens:CONFIG.maxTokens,
        system:systemPrompt,
        messages:messages
      })
    });
    if(!res.ok){const e=await res.text();throw new Error(e)}
    const data=await res.json();
    return data.content[0].text;
  }catch(e){
    console.error('Claude API error:',e);
    toast('AI request failed: '+e.message,'error');
    return null;
  }
}

function getSmartContext(topic='general'){
  const leads=getLeads(), rev=getRevenue(), reviews=getReviews(), keywords=getKeywords();
  const eng=getEngagement(), competitors=getCompetitors(), socialPosts=getSocialPosts();
  const campaigns=getCampaigns(), apiCosts=getApiCosts(), errors=getErrors();
  const wonLeads=leads.filter(l=>l.status==='Won');
  const thisMonth=new Date().toISOString().slice(0,7);
  const monthLeads=leads.filter(l=>l.dateAdded&&l.dateAdded.startsWith(thisMonth));
  const monthRev=rev.filter(r=>r.month===thisMonth);
  const gbRev=monthRev.filter(r=>r.business==='GB').reduce((s,r)=>s+r.amount,0);
  const gcRev=monthRev.filter(r=>r.business==='GC').reduce((s,r)=>s+r.amount,0);
  const now=new Date();
  const monthNames=['January','February','March','April','May','June','July','August','September','October','November','December'];
  const currentMonth=monthNames[now.getMonth()];

  let ctx=`Business Context:
- Green Bones Pest Control & Green Clean Disinfectants, Yuba City CA (Yuba-Sutter area)
- Current month: ${currentMonth} ${now.getFullYear()}
- Total leads: ${leads.length}, Won: ${wonLeads.length}, This month: ${monthLeads.length}
- Conversion rate: ${leads.length?(wonLeads.length/leads.length*100).toFixed(1):0}%
- Revenue this month: GB $${gbRev.toLocaleString()}, GC $${gcRev.toLocaleString()}, Combined: $${(gbRev+gcRev).toLocaleString()}
- Active keywords: ${keywords.length}, Reviews: ${reviews.length}
- Lead sources: ${JSON.stringify(leads.reduce((a,l)=>{a[l.source]=(a[l.source]||0)+1;return a},{}))}
- Lead statuses: ${JSON.stringify(leads.reduce((a,l)=>{a[l.status]=(a[l.status]||0)+1;return a},{}))}`;

  if(topic==='social'||topic==='general'){
    const thisWeekPosts=socialPosts.filter(p=>{const d=new Date(p.date);return d>=new Date(now-7*86400000)});
    ctx+=`\n- Social posts this week: ${thisWeekPosts.length}, Total scheduled: ${socialPosts.filter(p=>p.status==='Approved').length}`;
    if(eng.length){
      const recentEng=eng.slice(-10);
      const topPlatform=Object.entries(eng.reduce((a,e)=>{a[e.platform]=(a[e.platform]||0)+(e.likes||0)+(e.comments||0)+(e.shares||0);return a},{})).sort((a,b)=>b[1]-a[1])[0];
      ctx+=`\n- Top performing platform: ${topPlatform?topPlatform[0]:'N/A'}`;
    }
  }
  if(topic==='leads'||topic==='general'){
    const pendingLeads=leads.filter(l=>!['Won','Lost'].includes(l.status));
    ctx+=`\n- Pending leads: ${pendingLeads.length}`;
    ctx+=`\n- Recent leads: ${leads.slice(-5).map(l=>`${l.name}(${l.source},${l.status})`).join(', ')}`;
  }
  if(topic==='revenue'||topic==='general'){
    const totalRev=rev.reduce((s,r)=>s+r.amount,0);
    ctx+=`\n- Total all-time revenue: $${totalRev.toLocaleString()}`;
    const mktSpend=rev.filter(r=>r.type==='marketing').reduce((s,r)=>s+r.amount,0);
    ctx+=`\n- Marketing spend tracked: $${mktSpend.toLocaleString()}`;
  }
  if(topic==='competitors'||topic==='general'){
    ctx+=`\n- Competitors tracked: ${competitors.length}`;
    competitors.forEach(c=>ctx+=`\n  - ${c.name}: Rating ${c.rating||'?'}, ${c.reviewCount||0} reviews`);
  }
  if(topic==='seasonal'||topic==='general'){
    const seasonalPests={0:'Rodents, Overwintering pests',1:'Rodents, Overwintering pests',2:'Ants rising, Spiders rising, Termite swarms',3:'Ants rising, Spiders, Termites',4:'Mosquitoes rising, Ants peak, Wasps, Ticks',5:'Mosquitoes rising, Ants peak, Wasps peak, Ticks',6:'Mosquitoes peak, Spiders peak, Wasps peak, Bed bugs',7:'Mosquitoes peak, Spiders, Wasps, Bed bugs',8:'Rodents rising, Spiders, Overwintering pests',9:'Rodents rising, Overwintering pests rising',10:'Rodents peak, Overwintering pests, Wildlife exclusion',11:'Rodents peak, Overwintering pests, Wildlife exclusion'};
    ctx+=`\n- Seasonal focus (${currentMonth}): ${seasonalPests[now.getMonth()]}`;
  }
  if(errors.filter(e=>e.status==='Open').length>0){
    ctx+=`\n- OPEN ISSUES: ${errors.filter(e=>e.status==='Open').length} unresolved`;
  }
  return ctx;
}

function getBusinessContext(){
  return getSmartContext('general');
}

// ==================== MODULE 1: COMMAND CENTER (DASHBOARD) ====================
function renderDashboard(el){
  const leads=getLeads(), rev=getRevenue(), posts=getSocialPosts(), reviews=getReviews();
  const wonLeads=leads.filter(l=>l.status==='Won');
  const thisMonth=new Date().toISOString().slice(0,7);
  const monthLeads=leads.filter(l=>l.dateAdded&&l.dateAdded.startsWith(thisMonth));
  const monthWon=monthLeads.filter(l=>l.status==='Won');
  const monthRev=rev.filter(r=>r.month===thisMonth);
  const gbRev=monthRev.filter(r=>r.business==='GB').reduce((s,r)=>s+r.amount,0);
  const gcRev=monthRev.filter(r=>r.business==='GC').reduce((s,r)=>s+r.amount,0);
  const activeLeads=leads.filter(l=>!['Won','Lost'].includes(l.status));
  const convRate=monthLeads.length?(monthWon.length/monthLeads.length*100).toFixed(1):0;
  const approvedPosts=getSocialPosts().filter(p=>p.status==='Approved'||p.status==='Draft');

  el.innerHTML=`
    <div class="module-header">
      <h1><i class="fas fa-gauge-high" style="color:var(--accent-light)"></i> Command Center</h1>
      <p>At-a-glance overview of Green Bones & Green Clean</p>
    </div>
    <div id="winston-live-panel" class="card mb-16" style="border-left:3px solid var(--accent);display:none">
      <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px">
        <div style="display:flex;align-items:center;gap:10px">
          <span id="winston-status-dot" style="width:10px;height:10px;border-radius:50%;background:var(--success)"></span>
          <strong><i class="fas fa-satellite-dish"></i> Winston Live Feed</strong>
          <span id="winston-status-label" style="font-size:12px;color:var(--success)">Live</span>
        </div>
        <span id="winston-last-update" style="font-size:12px;color:var(--text2)"></span>
      </div>
      <div class="grid grid-6" style="gap:12px">
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-total">—</div><div style="font-size:11px;color:var(--text2)">Total Leads</div></div>
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-today">—</div><div style="font-size:11px;color:var(--text2)">Today</div></div>
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-week">—</div><div style="font-size:11px;color:var(--text2)">This Week</div></div>
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-month">—</div><div style="font-size:11px;color:var(--text2)">This Month</div></div>
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-score">—</div><div style="font-size:11px;color:var(--text2)">Avg Score</div></div>
        <div style="text-align:center"><div style="font-size:24px;font-weight:700" id="wl-top-src">—</div><div style="font-size:11px;color:var(--text2)">Top Source</div></div>
      </div>
      <div id="wl-sources" style="margin-top:12px;display:flex;gap:8px;flex-wrap:wrap"></div>
      <div id="wl-recent" style="margin-top:12px;max-height:200px;overflow-y:auto"></div>
    </div>
    <div class="grid grid-6 mb-16">
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-users"></i></div><div class="kpi-value">${activeLeads.length}</div><div class="kpi-label">Active Leads</div><div class="kpi-trend up"><i class="fas fa-arrow-up"></i> ${monthLeads.length} this month</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-handshake"></i></div><div class="kpi-value">${monthWon.length}</div><div class="kpi-label">Converted This Month</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-percent"></i></div><div class="kpi-value">${convRate}%</div><div class="kpi-label">Conversion Rate</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-dollar-sign"></i></div><div class="kpi-value">$${(gbRev+gcRev).toLocaleString()}</div><div class="kpi-label">Revenue This Month</div><div class="kpi-trend text-muted">GB $${gbRev.toLocaleString()} | GC $${gcRev.toLocaleString()}</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-bullhorn"></i></div><div class="kpi-value">${getCampaigns().filter(c=>c.status!=='Published').length}</div><div class="kpi-label">Active Campaigns</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-layer-group"></i></div><div class="kpi-value">${approvedPosts.length}</div><div class="kpi-label">Content Queue</div></div>
    </div>
    <div class="grid grid-2 mb-16">
      <div class="card"><div class="card-header"><span class="card-title">Lead Flow (30 Days)</span></div><canvas id="chart-lead-flow" height="200"></canvas></div>
      <div class="card"><div class="card-header"><span class="card-title">Revenue Trend (6 Months)</span></div><canvas id="chart-revenue-trend" height="200"></canvas></div>
    </div>
    <div class="grid grid-3 mb-16">
      <div class="card"><div class="card-header"><span class="card-title">Lead Sources</span></div><canvas id="chart-lead-sources" height="220"></canvas></div>
      <div class="card"><div class="card-header"><span class="card-title">Conversion Funnel</span></div><canvas id="chart-funnel" height="220"></canvas></div>
      <div class="card">
        <div class="card-header"><span class="card-title">Quick Actions</span></div>
        <button class="btn btn-primary w-full mb-8" onclick="aiWeeklyBrief()"><i class="fas fa-brain"></i> Weekly Strategy Brief</button>
        <button class="btn btn-secondary w-full mb-8" onclick="navigateTo('leads')"><i class="fas fa-plus"></i> Add New Lead</button>
        <button class="btn btn-secondary w-full mb-8" onclick="navigateTo('social')"><i class="fas fa-pen"></i> Create Content</button>
        <button class="btn btn-secondary w-full" onclick="navigateTo('seo')"><i class="fas fa-search"></i> SEO Check</button>
        <hr class="divider">
        <div class="section-title"><i class="fas fa-clock"></i> Recent Activity</div>
        <div id="activity-feed" style="max-height:200px;overflow-y:auto">${getActivity().slice(0,10).map(a=>`<div class="text-sm" style="padding:4px 0;border-bottom:1px solid var(--border)"><span class="text-muted">${formatDate(a.time)}</span> ${a.text}</div>`).join('')||'<div class="text-muted text-sm">No activity yet</div>'}</div>
      </div>
    </div>`;

  // Lead flow chart (last 30 days)
  const days30=[];for(let i=29;i>=0;i--){const d=new Date();d.setDate(d.getDate()-i);days30.push(d.toISOString().slice(0,10))}
  const gbByDay=days30.map(d=>leads.filter(l=>l.dateAdded===d&&l.business==='Green Bones Pest Control').length);
  const gcByDay=days30.map(d=>leads.filter(l=>l.dateAdded===d&&l.business==='Green Clean Disinfectants').length);
  createChart('chart-lead-flow',{type:'line',data:{labels:days30.map(d=>d.slice(5)),datasets:[
    {label:'Green Bones',data:gbByDay,borderColor:'#2D6A2D',tension:.4,fill:false},
    {label:'Green Clean',data:gcByDay,borderColor:'#3b82f6',tension:.4,fill:false}
  ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}}},scales:{x:{ticks:{color:'#9CA3AF',maxTicksLimit:10},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});

  // Revenue trend (6 months)
  const months6=[];for(let i=5;i>=0;i--){const d=new Date();d.setMonth(d.getMonth()-i);months6.push(d.toISOString().slice(0,7))}
  const gbRevByMonth=months6.map(m=>rev.filter(r=>r.month===m&&r.business==='GB').reduce((s,r)=>s+r.amount,0));
  const gcRevByMonth=months6.map(m=>rev.filter(r=>r.month===m&&r.business==='GC').reduce((s,r)=>s+r.amount,0));
  createChart('chart-revenue-trend',{type:'bar',data:{labels:months6,datasets:[
    {label:'Green Bones',data:gbRevByMonth,backgroundColor:'rgba(45,106,45,.7)'},
    {label:'Green Clean',data:gcRevByMonth,backgroundColor:'rgba(59,130,246,.7)'}
  ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}}},scales:{x:{stacked:true,ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{stacked:true,ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});

  // Lead sources doughnut
  const srcCounts={};leads.forEach(l=>{srcCounts[l.source]=(srcCounts[l.source]||0)+1});
  const srcLabels=Object.keys(srcCounts),srcData=Object.values(srcCounts);
  const srcColors=['#2D6A2D','#3b82f6','#F59E0B','#EF4444','#8B5CF6','#EC4899','#06B6D4','#22C55E','#F97316','#6366F1','#14B8A6'];
  createChart('chart-lead-sources',{type:'doughnut',data:{labels:srcLabels,datasets:[{data:srcData,backgroundColor:srcColors.slice(0,srcLabels.length)}]},options:{responsive:true,plugins:{legend:{position:'bottom',labels:{color:'#9CA3AF',boxWidth:12}}}}});

  // Funnel
  const funnelData=[leads.length,leads.filter(l=>l.status!=='New').length,leads.filter(l=>['Quoted','Follow Up','Won','Lost'].includes(l.status)).length,wonLeads.length];
  createChart('chart-funnel',{type:'bar',data:{labels:['Leads','Contacted','Quoted','Won'],datasets:[{data:funnelData,backgroundColor:['#3b82f6','#8B5CF6','#F59E0B','#22C55E']}]},options:{indexAxis:'y',responsive:true,plugins:{legend:{display:false}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{display:false}}}}});
}

async function aiWeeklyBrief(){
  showModal('<div class="relative" style="min-height:200px"><div class="loading-overlay"><div class="spinner"></div><div>Generating Weekly Strategy Brief...</div></div></div>','modal-lg');
  const ctx=getBusinessContext();
  const result=await callClaude(
    'You are an expert small business marketing strategist for pest control and disinfection services in the Yuba-Sutter area of Northern California. Provide actionable, specific advice.',
    `Based on this data, give me a comprehensive weekly strategy brief:\n\n${ctx}\n\nCover: 1) What's working 2) What needs attention 3) This week's priorities 4) Seasonal opportunities right now 5) Specific action items for each business. Use headers and bullet points.`
  );
  if(result){
    showModal(`<h2><i class="fas fa-brain" style="color:var(--accent-light)"></i> Weekly Strategy Brief</h2><div style="white-space:pre-wrap;line-height:1.7">${result.replace(/#{1,3}\s/g,'<strong>').replace(/\n/g,'<br>')}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
  }
}

// ==================== MODULE 2: LEAD PIPELINE & CRM ====================
let leadFilter={business:'',source:'',status:'',scoreMin:'',scoreMax:'',city:'',search:''};

function renderLeads(el){
  const leads=getLeads();
  el.innerHTML=`
    <div class="module-header flex-between">
      <div><h1><i class="fas fa-users" style="color:var(--accent-light)"></i> Lead Pipeline & CRM</h1><p>Manage leads for both businesses</p></div>
      <div class="flex gap-8">
        <button class="btn btn-primary" onclick="showAddLeadModal()"><i class="fas fa-plus"></i> Add Lead</button>
        <button class="btn btn-secondary" onclick="exportLeadsCSV()"><i class="fas fa-file-csv"></i> CSV Export</button>
        <button class="btn btn-ghost" onclick="toggleLeadAnalytics()"><i class="fas fa-chart-bar"></i> Analytics</button>
      </div>
    </div>
    <div id="lead-analytics-panel" class="card mb-16 hidden">
      <div class="card-header"><span class="card-title">Lead Analytics</span></div>
      <div class="grid grid-3 gap-16">
        <div><canvas id="chart-leads-by-source" height="200"></canvas></div>
        <div><canvas id="chart-conversion-by-source" height="200"></canvas></div>
        <div><canvas id="chart-leads-by-city" height="200"></canvas></div>
      </div>
    </div>
    <div class="card">
      <div class="toolbar">
        <div class="search-input"><i class="fas fa-search"></i><input type="text" placeholder="Search leads..." oninput="leadFilter.search=this.value;renderLeadTable()"></div>
        <select onchange="leadFilter.business=this.value;renderLeadTable()"><option value="">All Businesses</option><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select>
        <select onchange="leadFilter.source=this.value;renderLeadTable()"><option value="">All Sources</option>${CONFIG.leadSources.map(s=>`<option>${s}</option>`).join('')}</select>
        <select onchange="leadFilter.status=this.value;renderLeadTable()"><option value="">All Statuses</option>${CONFIG.leadStatuses.map(s=>`<option>${s}</option>`).join('')}</select>
        <select onchange="leadFilter.city=this.value;renderLeadTable()"><option value="">All Cities</option>${CONFIG.serviceAreas.map(c=>`<option>${c}</option>`).join('')}</select>
      </div>
      <div class="overflow-auto"><table id="lead-table"><thead><tr>
        <th>ID</th><th>Date</th><th>Business</th><th>Source</th><th>Name</th><th>Phone</th><th>Service</th><th>Score</th><th>Status</th><th>Quote</th><th>Actions</th>
      </tr></thead><tbody id="lead-tbody"></tbody></table></div>
    </div>`;
  renderLeadTable();
}

function renderLeadTable(){
  let leads=getLeads();
  const f=leadFilter;
  if(f.business)leads=leads.filter(l=>l.business===f.business);
  if(f.source)leads=leads.filter(l=>l.source===f.source);
  if(f.status)leads=leads.filter(l=>l.status===f.status);
  if(f.city)leads=leads.filter(l=>l.city===f.city);
  if(f.search){const s=f.search.toLowerCase();leads=leads.filter(l=>(l.name||'').toLowerCase().includes(s)||(l.email||'').toLowerCase().includes(s)||(l.phone||'').includes(s))}
  const tbody=document.getElementById('lead-tbody');
  if(!tbody)return;
  tbody.innerHTML=leads.map(l=>{
    const scoreClass=l.score>=8?'text-success':l.score>=5?'text-warn':'text-danger';
    const rowBg=l.score>=8?'rgba(34,197,94,.05)':l.score>=5?'rgba(245,158,11,.05)':l.score<=4&&l.score>0?'rgba(239,68,68,.05)':'';
    return `<tr style="background:${rowBg}">
      <td>${l.id}</td><td>${formatDate(l.dateAdded)}</td>
      <td><span class="text-xs ${l.business.includes('Bones')?'text-success':'text-warn'}">${l.business.includes('Bones')?'GB':'GC'}</span></td>
      <td>${l.source}</td><td><strong>${l.name||'-'}</strong></td><td>${l.phone||'-'}</td>
      <td class="text-sm">${l.service||'-'}</td>
      <td><span class="${scoreClass}" style="font-weight:700">${l.score||'-'}</span></td>
      <td>${statusBadge(l.status)}</td>
      <td>${l.quoteAmount?'$'+Number(l.quoteAmount).toLocaleString():'-'}</td>
      <td>
        <button class="btn-icon" title="Edit" onclick="showEditLeadModal(${l.id})"><i class="fas fa-edit"></i></button>
        <button class="btn-icon" title="AI Score" onclick="aiScoreLead(${l.id})"><i class="fas fa-brain"></i></button>
        <button class="btn-icon" title="Follow-up" onclick="aiFollowUp(${l.id})"><i class="fas fa-reply"></i></button>
        <button class="btn-icon" title="Delete" onclick="deleteLead(${l.id})"><i class="fas fa-trash"></i></button>
      </td></tr>`}).join('')||'<tr><td colspan="11" class="text-muted text-center">No leads found</td></tr>';
}

function showAddLeadModal(){
  const today=new Date().toISOString().slice(0,10);
  showModal(`<h2><i class="fas fa-user-plus"></i> Add New Lead</h2>
    <div class="form-row">
      <div class="form-group"><label>Business</label><select id="nl-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
      <div class="form-group"><label>Source</label><select id="nl-src">${CONFIG.leadSources.map(s=>`<option>${s}</option>`).join('')}</select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Contact Name</label><input id="nl-name"></div>
      <div class="form-group"><label>Phone</label><input id="nl-phone"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Email</label><input id="nl-email" type="email"></div>
      <div class="form-group"><label>City</label><select id="nl-city">${CONFIG.serviceAreas.map(c=>`<option>${c}</option>`).join('')}</select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Service Requested</label><select id="nl-svc">${CONFIG.gbServices.map(s=>`<option>${s}</option>`).join('')}${CONFIG.gcServices.map(s=>`<option>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Quote Amount ($)</label><input id="nl-quote" type="number"></div>
    </div>
    <div class="form-group"><label>Notes</label><textarea id="nl-notes"></textarea></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addLead()">Add Lead</button></div>`);
  // Update service dropdown based on business
  document.getElementById('nl-biz').addEventListener('change',function(){
    const svc=document.getElementById('nl-svc');
    const svcs=this.value.includes('Bones')?CONFIG.gbServices:CONFIG.gcServices;
    svc.innerHTML=svcs.map(s=>`<option>${s}</option>`).join('');
  });
}

function addLead(){
  const leads=getLeads();
  const lead={
    id:nextId(leads),dateAdded:new Date().toISOString().slice(0,10),
    business:document.getElementById('nl-biz').value,
    source:document.getElementById('nl-src').value,
    name:document.getElementById('nl-name').value,
    phone:document.getElementById('nl-phone').value,
    email:document.getElementById('nl-email').value,
    city:document.getElementById('nl-city').value,
    service:document.getElementById('nl-svc').value,
    quoteAmount:document.getElementById('nl-quote').value||0,
    notes:document.getElementById('nl-notes').value,
    score:0,status:'New',followUp:'',lostReason:''
  };
  leads.push(lead);saveLeads(leads);
  addActivity(`New lead added: ${lead.name} (${lead.business.includes('Bones')?'GB':'GC'})`,'leads');
  closeModal();toast('Lead added');renderLeadTable();
}

function showEditLeadModal(id){
  const leads=getLeads();const l=leads.find(x=>x.id===id);if(!l)return;
  showModal(`<h2><i class="fas fa-edit"></i> Edit Lead #${l.id}</h2>
    <div class="form-row">
      <div class="form-group"><label>Business</label><select id="el-biz"><option ${l.business.includes('Bones')?'selected':''}>Green Bones Pest Control</option><option ${l.business.includes('Clean')?'selected':''}>Green Clean Disinfectants</option></select></div>
      <div class="form-group"><label>Source</label><select id="el-src">${CONFIG.leadSources.map(s=>`<option ${s===l.source?'selected':''}>${s}</option>`).join('')}</select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Name</label><input id="el-name" value="${l.name||''}"></div>
      <div class="form-group"><label>Phone</label><input id="el-phone" value="${l.phone||''}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Email</label><input id="el-email" value="${l.email||''}"></div>
      <div class="form-group"><label>City</label><select id="el-city">${CONFIG.serviceAreas.map(c=>`<option ${c===l.city?'selected':''}>${c}</option>`).join('')}</select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Service</label><select id="el-svc">${[...CONFIG.gbServices,...CONFIG.gcServices].map(s=>`<option ${s===l.service?'selected':''}>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Score (1-10)</label><input id="el-score" type="number" min="1" max="10" value="${l.score||''}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Status</label><select id="el-status">${CONFIG.leadStatuses.map(s=>`<option ${s===l.status?'selected':''}>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Quote Amount ($)</label><input id="el-quote" type="number" value="${l.quoteAmount||''}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Follow-Up Date</label><input id="el-followup" type="date" value="${l.followUp||''}"></div>
      <div class="form-group"><label>Lost Reason</label><input id="el-lost" value="${l.lostReason||''}"></div>
    </div>
    <div class="form-group"><label>Notes</label><textarea id="el-notes">${l.notes||''}</textarea></div>
    <div class="form-actions">
      <button class="btn btn-secondary" onclick="closeModal()">Cancel</button>
      <button class="btn btn-warn" onclick="aiScoreLead(${l.id})"><i class="fas fa-brain"></i> AI Score</button>
      <button class="btn btn-primary" onclick="saveLead(${l.id})">Save</button>
    </div>`);
}

function saveLead(id){
  const leads=getLeads();const idx=leads.findIndex(x=>x.id===id);if(idx<0)return;
  const oldStatus=leads[idx].status;
  leads[idx]={...leads[idx],
    business:document.getElementById('el-biz').value,source:document.getElementById('el-src').value,
    name:document.getElementById('el-name').value,phone:document.getElementById('el-phone').value,
    email:document.getElementById('el-email').value,city:document.getElementById('el-city').value,
    service:document.getElementById('el-svc').value,score:parseInt(document.getElementById('el-score').value)||0,
    status:document.getElementById('el-status').value,quoteAmount:document.getElementById('el-quote').value,
    followUp:document.getElementById('el-followup').value,lostReason:document.getElementById('el-lost').value,
    notes:document.getElementById('el-notes').value
  };
  saveLeads(leads);
  // Cross-brand upsell on Won
  const newStatus=leads[idx].status;
  if(newStatus==='Won'&&oldStatus!=='Won'){
    addActivity(`Lead WON: ${leads[idx].name} ($${leads[idx].quoteAmount}) - ${leads[idx].business.includes('Bones')?'GB':'GC'}`,'leads');
    const otherBiz=leads[idx].business.includes('Bones')?'Green Clean Disinfectants':'Green Bones Pest Control';
    setTimeout(()=>{
      if(confirm(`Lead marked as Won! Generate a cross-sell pitch for ${otherBiz}?`)){
        aiUpsellPitch(id);
      }
    },300);
  }
  closeModal();toast('Lead updated');renderLeadTable();
}

function deleteLead(id){
  if(!confirm('Delete this lead?'))return;
  const leads=getLeads().filter(l=>l.id!==id);saveLeads(leads);toast('Lead deleted');renderLeadTable();
}

async function aiScoreLead(id){
  const l=getLeads().find(x=>x.id===id);if(!l)return;
  toast('Scoring lead with AI...','info');
  const result=await callClaude(
    'You are an expert lead scoring system for pest control and disinfection services in the Yuba-Sutter CA area. Score leads 1-10.',
    `Score this lead (1-10) and explain briefly:\nBusiness: ${l.business}\nService: ${l.service}\nSource: ${l.source}\nCity: ${l.city}\nNotes: ${l.notes||'None'}\nQuote: $${l.quoteAmount||'Not quoted'}\nStatus: ${l.status}\n\nRespond with: SCORE: [number]\nREASON: [brief explanation]`
  );
  if(result){
    const scoreMatch=result.match(/SCORE:\s*(\d+)/i);
    if(scoreMatch){
      const leads=getLeads();const idx=leads.findIndex(x=>x.id===id);
      if(idx>=0){leads[idx].score=parseInt(scoreMatch[1]);saveLeads(leads);renderLeadTable()}
    }
    showModal(`<h2><i class="fas fa-brain"></i> AI Lead Score</h2><div style="white-space:pre-wrap">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`);
  }
}

async function aiFollowUp(id){
  const l=getLeads().find(x=>x.id===id);if(!l)return;
  toast('Generating follow-up...','info');
  const result=await callClaude(
    'You are a professional pest control and disinfection business communication expert. Write follow-up messages that are friendly, professional, and effective.',
    `Generate a follow-up message for this lead:\nName: ${l.name}\nBusiness: ${l.business}\nService: ${l.service}\nStatus: ${l.status}\nQuote: $${l.quoteAmount||'Not yet quoted'}\nNotes: ${l.notes||'None'}\nLast contact: ${l.followUp||l.dateAdded}\n\nProvide:\n1. A short text message version (under 160 chars)\n2. An email version (professional, warm)\n3. A phone script`
  );
  if(result){
    showModal(`<h2><i class="fas fa-reply"></i> Follow-Up for ${l.name}</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button><button class="btn btn-primary" onclick="navigator.clipboard.writeText(document.querySelector('#modal-content div[style]').innerText);toast('Copied!')">Copy All</button></div>`,'modal-lg');
  }
}

async function aiUpsellPitch(id){
  const l=getLeads().find(x=>x.id===id);if(!l)return;
  const otherBiz=l.business.includes('Bones')?'Green Clean Disinfectants':'Green Bones Pest Control';
  toast('Generating upsell pitch...','info');
  const result=await callClaude(
    `You help cross-sell between Green Bones Pest Control and Green Clean Disinfectants in the Yuba-Sutter CA area.`,
    `This customer just booked ${l.service} with ${l.business}. Generate a natural, personalized cross-sell pitch for ${otherBiz}.\nCustomer: ${l.name}\nCity: ${l.city}\nService booked: ${l.service}\n\nMake it feel like a genuine value-add, not a hard sell. Provide a text message and email version.`
  );
  if(result) showModal(`<h2><i class="fas fa-handshake"></i> Cross-Sell Pitch</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

function toggleLeadAnalytics(){
  const panel=document.getElementById('lead-analytics-panel');
  panel.classList.toggle('hidden');
  if(!panel.classList.contains('hidden')){
    const leads=getLeads();
    // By source
    const srcCounts={};leads.forEach(l=>{srcCounts[l.source]=(srcCounts[l.source]||0)+1});
    createChart('chart-leads-by-source',{type:'bar',data:{labels:Object.keys(srcCounts),datasets:[{label:'Leads',data:Object.values(srcCounts),backgroundColor:'rgba(45,106,45,.7)'}]},options:{responsive:true,plugins:{legend:{display:false},title:{display:true,text:'Leads by Source',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});
    // Conversion by source
    const srcWon={};leads.filter(l=>l.status==='Won').forEach(l=>{srcWon[l.source]=(srcWon[l.source]||0)+1});
    const convData=Object.keys(srcCounts).map(s=>srcCounts[s]?((srcWon[s]||0)/srcCounts[s]*100).toFixed(1):0);
    createChart('chart-conversion-by-source',{type:'bar',data:{labels:Object.keys(srcCounts),datasets:[{label:'Conv %',data:convData,backgroundColor:'rgba(59,130,246,.7)'}]},options:{responsive:true,plugins:{legend:{display:false},title:{display:true,text:'Conversion Rate by Source',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});
    // By city
    const cityCounts={};leads.forEach(l=>{if(l.city)cityCounts[l.city]=(cityCounts[l.city]||0)+1});
    createChart('chart-leads-by-city',{type:'bar',data:{labels:Object.keys(cityCounts),datasets:[{label:'Leads',data:Object.values(cityCounts),backgroundColor:'rgba(245,158,11,.7)'}]},options:{responsive:true,plugins:{legend:{display:false},title:{display:true,text:'Leads by City',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});
  }
}

function exportLeadsCSV(){
  const leads=getLeads();
  const headers=['ID','Date','Business','Source','Name','Phone','Email','City','Service','Score','Status','Quote','Notes'];
  const rows=leads.map(l=>[l.id,l.dateAdded,l.business,l.source,l.name,l.phone,l.email,l.city,l.service,l.score,l.status,l.quoteAmount,`"${(l.notes||'').replace(/"/g,'""')}"`]);
  const csv=[headers.join(','),...rows.map(r=>r.join(','))].join('\n');
  downloadFile(csv,'leads-export.csv','text/csv');
  toast('Leads exported');
}

// ==================== MODULE 3: SEO COMMAND CENTER ====================
let seoTab='keywords';

function renderSEO(el){
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-search" style="color:var(--accent-light)"></i> SEO Command Center</h1><p>Keywords, content, backlinks, and site health</p></div>
    <div class="tabs">
      <div class="tab ${seoTab==='keywords'?'active':''}" onclick="seoTab='keywords';renderSEO(document.getElementById('main'))">Keywords</div>
      <div class="tab ${seoTab==='blog'?'active':''}" onclick="seoTab='blog';renderSEO(document.getElementById('main'))">Blog Pipeline</div>
      <div class="tab ${seoTab==='health'?'active':''}" onclick="seoTab='health';renderSEO(document.getElementById('main'))">Site Health</div>
      <div class="tab ${seoTab==='backlinks'?'active':''}" onclick="seoTab='backlinks';renderSEO(document.getElementById('main'))">Backlinks</div>
    </div>
    <div id="seo-content"></div>`;
  const content=document.getElementById('seo-content');
  if(seoTab==='keywords') renderKeywords(content);
  else if(seoTab==='blog') renderBlogPipeline(content);
  else if(seoTab==='health') renderSiteHealth(content);
  else if(seoTab==='backlinks') renderBacklinks(content);
}

function renderKeywords(el){
  const kws=getKeywords();
  el.innerHTML=`
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddKeywordModal()"><i class="fas fa-plus"></i> Add Keyword</button>
      <button class="btn btn-warn" onclick="aiSuggestKeywords()"><i class="fas fa-brain"></i> AI Suggest Keywords</button>
      <div class="search-input" style="margin-left:auto"><i class="fas fa-search"></i><input type="text" placeholder="Filter keywords..." oninput="filterKeywordTable(this.value)"></div>
    </div>
    <div class="card mb-16"><div class="card-header"><span class="card-title">Keyword Rank Trends</span></div><canvas id="chart-keyword-ranks" height="200"></canvas></div>
    <div class="card overflow-auto">
      <table><thead><tr>
        <th onclick="sortKeywords('keyword')" style="cursor:pointer">Keyword <i class="fas fa-sort text-muted"></i></th>
        <th>Business</th>
        <th onclick="sortKeywords('volume')" style="cursor:pointer">Volume <i class="fas fa-sort text-muted"></i></th>
        <th onclick="sortKeywords('currentRank')" style="cursor:pointer">Rank <i class="fas fa-sort text-muted"></i></th>
        <th>Prev</th><th>Change</th>
        <th onclick="sortKeywords('priority')" style="cursor:pointer">Priority <i class="fas fa-sort text-muted"></i></th>
        <th>Target URL</th><th>Actions</th>
      </tr></thead>
      <tbody id="keyword-tbody">${renderKeywordRows(kws)}</tbody></table>
    </div>`;
  // Rank chart (inverted Y axis — position 1 at top)
  const tracked=kws.filter(k=>k.currentRank>0).slice(0,8);
  if(tracked.length){
    const colors=['#2D6A2D','#3b82f6','#F59E0B','#EF4444','#8B5CF6','#EC4899','#06B6D4','#22C55E'];
    const datasets=tracked.map((k,i)=>{
      const hist=k.history||[];
      const data=hist.length?hist.map(h=>h.rank):[k.prevRank||k.currentRank,k.currentRank];
      return {label:k.keyword,data:data,borderColor:colors[i%colors.length],tension:.3,fill:false,pointRadius:3};
    });
    const maxLabels=Math.max(...datasets.map(d=>d.data.length));
    const labels=Array.from({length:maxLabels},(_,i)=>i===maxLabels-1?'Current':'Week '+(i+1));
    createChart('chart-keyword-ranks',{type:'line',data:{labels,datasets},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF',boxWidth:12}}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{reverse:true,min:1,ticks:{color:'#9CA3AF',stepSize:1},grid:{color:'#2A2D37'},title:{display:true,text:'Position (lower is better)',color:'#9CA3AF'}}}}});
  }
}

function renderKeywordRows(kws){
  return kws.map(k=>{
    const change=k.prevRank&&k.currentRank?(k.prevRank-k.currentRank):0;
    const arrow=change>0?'<i class="fas fa-arrow-up text-success"></i>':change<0?'<i class="fas fa-arrow-down text-danger"></i>':'<i class="fas fa-minus text-muted"></i>';
    return `<tr data-keyword="${(k.keyword||'').toLowerCase()}">
      <td><strong>${k.keyword}</strong></td><td class="text-sm">${k.business||'Both'}</td>
      <td>${k.volume||'-'}</td><td><strong>${k.currentRank||'-'}</strong></td><td>${k.prevRank||'-'}</td>
      <td>${arrow} ${Math.abs(change)||''}</td>
      <td><span class="badge ${k.priority==='High'?'badge-new':k.priority==='Medium'?'badge-quoted':'badge-lost'}">${k.priority||'Medium'}</span></td>
      <td class="text-xs text-muted">${k.targetUrl||'-'}</td>
      <td>
        <button class="btn-icon" onclick="editKeyword(${k.id})"><i class="fas fa-edit"></i></button>
        <button class="btn-icon" onclick="deleteKeyword(${k.id})"><i class="fas fa-trash"></i></button>
      </td></tr>`}).join('')||'<tr><td colspan="9" class="text-muted">No keywords tracked yet</td></tr>';
}

let kwSortField='',kwSortAsc=true;
function sortKeywords(field){
  if(kwSortField===field)kwSortAsc=!kwSortAsc;else{kwSortField=field;kwSortAsc=true}
  const kws=[...getKeywords()].sort((a,b)=>{
    let va=a[field]||'',vb=b[field]||'';
    if(typeof va==='number')return kwSortAsc?va-vb:vb-va;
    return kwSortAsc?String(va).localeCompare(String(vb)):String(vb).localeCompare(String(va));
  });
  document.getElementById('keyword-tbody').innerHTML=renderKeywordRows(kws);
}

function filterKeywordTable(q){
  const rows=document.querySelectorAll('#keyword-tbody tr[data-keyword]');
  rows.forEach(r=>r.style.display=r.dataset.keyword.includes(q.toLowerCase())?'':'none');
}

function showAddKeywordModal(){
  showModal(`<h2><i class="fas fa-key"></i> Add Keyword</h2>
    <div class="form-row">
      <div class="form-group"><label>Keyword</label><input id="kw-word"></div>
      <div class="form-group"><label>Business</label><select id="kw-biz"><option>Green Bones</option><option>Green Clean</option><option>Both</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Search Volume</label><input id="kw-vol" type="number"></div>
      <div class="form-group"><label>Current Rank</label><input id="kw-rank" type="number"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Target URL</label><input id="kw-url"></div>
      <div class="form-group"><label>Priority</label><select id="kw-pri"><option>High</option><option>Medium</option><option>Low</option></select></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addKeyword()">Add</button></div>`);
}

function addKeyword(){
  const kws=getKeywords();
  kws.push({id:nextId(kws),keyword:document.getElementById('kw-word').value,business:document.getElementById('kw-biz').value,
    volume:parseInt(document.getElementById('kw-vol').value)||0,currentRank:parseInt(document.getElementById('kw-rank').value)||0,
    prevRank:0,targetUrl:document.getElementById('kw-url').value,priority:document.getElementById('kw-pri').value,
    history:[]});
  saveKeywords(kws);closeModal();toast('Keyword added');renderSEO(document.getElementById('main'));
}

function editKeyword(id){
  const k=getKeywords().find(x=>x.id===id);if(!k)return;
  showModal(`<h2>Edit Keyword</h2>
    <div class="form-row">
      <div class="form-group"><label>Keyword</label><input id="ekw-word" value="${k.keyword}"></div>
      <div class="form-group"><label>Current Rank</label><input id="ekw-rank" type="number" value="${k.currentRank||''}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Volume</label><input id="ekw-vol" type="number" value="${k.volume||''}"></div>
      <div class="form-group"><label>Priority</label><select id="ekw-pri"><option ${k.priority==='High'?'selected':''}>High</option><option ${k.priority==='Medium'?'selected':''}>Medium</option><option ${k.priority==='Low'?'selected':''}>Low</option></select></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="saveKeyword(${id})">Save</button></div>`);
}

function saveKeyword(id){
  const kws=getKeywords();const idx=kws.findIndex(x=>x.id===id);if(idx<0)return;
  kws[idx].prevRank=kws[idx].currentRank;
  kws[idx].keyword=document.getElementById('ekw-word').value;
  kws[idx].currentRank=parseInt(document.getElementById('ekw-rank').value)||0;
  kws[idx].volume=parseInt(document.getElementById('ekw-vol').value)||0;
  kws[idx].priority=document.getElementById('ekw-pri').value;
  saveKeywords(kws);closeModal();toast('Keyword updated');renderSEO(document.getElementById('main'));
}

function deleteKeyword(id){
  if(!confirm('Delete keyword?'))return;
  saveKeywords(getKeywords().filter(k=>k.id!==id));toast('Deleted');renderSEO(document.getElementById('main'));
}

async function aiSuggestKeywords(){
  toast('AI generating keyword suggestions...','info');
  showModal('<div class="relative" style="min-height:200px"><div class="loading-overlay"><div class="spinner"></div><div>Generating keyword suggestions...</div></div></div>','modal-xl');
  const existing=getKeywords().map(k=>k.keyword).join(', ');
  const result=await callClaude(
    'You are an expert local SEO strategist for pest control and disinfection in Yuba-Sutter, Northern California. ALWAYS respond with valid JSON.',
    `Suggest 20 high-value keywords for Green Bones Pest Control and Green Clean Disinfectants in Yuba City CA.\n\nExisting keywords: ${existing||'None'}\n\nRespond ONLY with a JSON array. Each object must have: keyword, business (Green Bones/Green Clean/Both), volume (number), difficulty (Easy/Medium/Hard), intent (Informational/Commercial/Transactional).\n\nExample: [{"keyword":"pest control yuba city","business":"Green Bones","volume":320,"difficulty":"Medium","intent":"Commercial"}]\n\nFocus on local intent, "near me" variants, service-specific, and long-tail keywords.`
  );
  if(result){
    try{
      const jsonMatch=result.match(/\[[\s\S]*\]/);
      if(jsonMatch){
        const suggestions=JSON.parse(jsonMatch[0]);
        window._kwSuggestions=suggestions;
        showModal(`<h2><i class="fas fa-brain"></i> AI Keyword Suggestions</h2>
          <p class="text-muted mb-16">Click "Add" to add any keyword to your tracker</p>
          <div class="overflow-auto" style="max-height:60vh">
          <table><thead><tr><th>Keyword</th><th>Business</th><th>Volume</th><th>Difficulty</th><th>Intent</th><th>Action</th></tr></thead>
          <tbody>${suggestions.map((s,i)=>`<tr id="kwsug-${i}">
            <td><strong>${s.keyword}</strong></td><td class="text-sm">${s.business}</td>
            <td>${s.volume}</td>
            <td><span class="badge ${s.difficulty==='Easy'?'badge-won':s.difficulty==='Medium'?'badge-quoted':'badge-lost'}">${s.difficulty}</span></td>
            <td class="text-sm">${s.intent}</td>
            <td><button class="btn btn-sm btn-primary" onclick="addSuggestedKeyword(${i})"><i class="fas fa-plus"></i> Add</button></td>
          </tr>`).join('')}</tbody></table></div>
          <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-xl');
        return;
      }
    }catch(e){console.log('JSON parse failed, showing raw')}
    showModal(`<h2><i class="fas fa-brain"></i> Keyword Suggestions</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
  }
}

function addSuggestedKeyword(idx){
  const s=window._kwSuggestions?.[idx];if(!s)return;
  const kws=getKeywords();
  if(kws.find(k=>k.keyword.toLowerCase()===s.keyword.toLowerCase())){toast('Already tracked','info');return}
  kws.push({id:nextId(kws),keyword:s.keyword,business:s.business,volume:s.volume||0,currentRank:0,prevRank:0,
    targetUrl:'',priority:s.difficulty==='Easy'?'High':s.difficulty==='Medium'?'Medium':'Low',history:[]});
  saveKeywords(kws);
  const row=document.getElementById('kwsug-'+idx);
  if(row)row.querySelector('button').outerHTML='<span class="badge badge-won">Added</span>';
  toast('Keyword added to tracker');
}

// Blog Pipeline
function renderBlogPipeline(el){
  const posts=getBlogPosts();
  const statuses=['Idea','Writing','Review','Published'];
  el.innerHTML=`
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddBlogModal()"><i class="fas fa-plus"></i> Add Post</button>
      <button class="btn btn-warn" onclick="showGenerateBlogModal()"><i class="fas fa-brain"></i> Generate Blog Post</button>
    </div>
    <div class="kanban">
      ${statuses.map(s=>{
        const items=posts.filter(p=>p.status===s);
        return `<div class="kanban-col"><div class="kanban-col-title">${s} <span class="count">${items.length}</span></div>
          ${items.map(p=>`<div class="kanban-card" onclick="showBlogDetail(${p.id})">
            <div class="card-brand ${p.business&&p.business.includes('Bones')?'gb':'gc'}">${p.business&&p.business.includes('Bones')?'GB':'GC'}</div>
            <div style="font-weight:600;font-size:13px">${p.title||'Untitled'}</div>
            <div class="text-xs text-muted mt-8">${p.keyword||''} · ${p.wordCount||0} words</div>
          </div>`).join('')}
        </div>`}).join('')}
    </div>`;
}

function showAddBlogModal(){
  showModal(`<h2><i class="fas fa-file-alt"></i> Add Blog Post</h2>
    <div class="form-row">
      <div class="form-group"><label>Title</label><input id="bp-title"></div>
      <div class="form-group"><label>Business</label><select id="bp-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Target Keyword</label><input id="bp-kw"></div>
      <div class="form-group"><label>Status</label><select id="bp-status"><option>Idea</option><option>Writing</option><option>Review</option><option>Published</option></select></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addBlogPost()">Add</button></div>`);
}

function addBlogPost(){
  const posts=getBlogPosts();
  posts.push({id:nextId(posts),title:document.getElementById('bp-title').value,business:document.getElementById('bp-biz').value,
    keyword:document.getElementById('bp-kw').value,status:document.getElementById('bp-status').value,
    wordCount:0,content:'',date:new Date().toISOString().slice(0,10)});
  saveBlogPosts(posts);closeModal();toast('Blog post added');renderSEO(document.getElementById('main'));
}

function showBlogDetail(id){
  const p=getBlogPosts().find(x=>x.id===id);if(!p)return;
  showModal(`<h2>${p.title||'Untitled'}</h2>
    <div class="form-row">
      <div class="form-group"><label>Status</label><select id="bd-status">${['Idea','Writing','Review','Published'].map(s=>`<option ${s===p.status?'selected':''}>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Word Count</label><input id="bd-wc" type="number" value="${p.wordCount||0}"></div>
    </div>
    <div class="form-group"><label>Content</label><textarea id="bd-content" style="min-height:200px">${p.content||''}</textarea></div>
    <div class="form-actions">
      <button class="btn btn-danger btn-sm" onclick="deleteBlogPost(${id})">Delete</button>
      <button class="btn btn-secondary" onclick="closeModal()">Cancel</button>
      <button class="btn btn-primary" onclick="saveBlogPost(${id})">Save</button>
    </div>`,'modal-lg');
}

function saveBlogPost(id){
  const posts=getBlogPosts();const idx=posts.findIndex(x=>x.id===id);if(idx<0)return;
  posts[idx].status=document.getElementById('bd-status').value;
  posts[idx].wordCount=parseInt(document.getElementById('bd-wc').value)||0;
  posts[idx].content=document.getElementById('bd-content').value;
  saveBlogPosts(posts);closeModal();toast('Saved');renderSEO(document.getElementById('main'));
}

function deleteBlogPost(id){
  if(!confirm('Delete?'))return;
  saveBlogPosts(getBlogPosts().filter(p=>p.id!==id));closeModal();toast('Deleted');renderSEO(document.getElementById('main'));
}

function showGenerateBlogModal(){
  showModal(`<h2><i class="fas fa-brain"></i> Generate Blog Post</h2>
    <div class="form-row">
      <div class="form-group"><label>Business</label><select id="gb-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
      <div class="form-group"><label>Category</label><select id="gb-cat">
        <optgroup label="Green Bones"><option>Pest Guides</option><option>Treatment Methods</option><option>Seasonal Alerts</option><option>Prevention Tips</option><option>Commercial Pest Control</option><option>Local Area Guides</option></optgroup>
        <optgroup label="Green Clean"><option>Disinfection Methods</option><option>Industry Compliance</option><option>Health & Safety</option><option>Commercial Cleaning</option><option>Residential Deep Clean</option></optgroup>
      </select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Primary Keyword</label><input id="gb-kw1" placeholder="e.g., ant control yuba city"></div>
      <div class="form-group"><label>Secondary Keywords (comma-separated)</label><input id="gb-kw2"></div>
    </div>
    <div class="form-group"><label>Topic (or leave blank for AI to suggest)</label><input id="gb-topic"></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="generateBlogPost()"><i class="fas fa-brain"></i> Generate</button></div>`,'modal-lg');
}

async function generateBlogPost(){
  const biz=document.getElementById('gb-biz').value;
  const cat=document.getElementById('gb-cat').value;
  const kw1=document.getElementById('gb-kw1').value;
  const kw2=document.getElementById('gb-kw2').value;
  const topic=document.getElementById('gb-topic').value;
  showModal('<div class="relative" style="min-height:300px"><div class="loading-overlay"><div class="spinner"></div><div>Generating complete blog post... this may take a moment</div></div></div>','modal-xl');
  const result=await callClaude(
    `You are an expert SEO content writer for ${biz} in Yuba City, California, serving the Yuba-Sutter area.`,
    `Generate a COMPLETE SEO-optimized blog post:\n\nBusiness: ${biz}\nCategory: ${cat}\nPrimary Keyword: ${kw1}\nSecondary Keywords: ${kw2}\nTopic: ${topic||'Suggest the best topic'}\n\nProvide ALL of the following:\n1. SEO Title (max 60 chars)\n2. Meta Description (max 155 chars)\n3. URL Slug\n4. Full article (1200-1800 words) with H2/H3 structure, naturally using the keywords\n5. Internal linking suggestions\n6. CTA paragraph\n7. 3 FAQ items (question + answer)\n8. Social sharing snippets (Facebook, Instagram, X/Twitter)\n\nMake it authoritative, locally relevant (mention Yuba City, Marysville, etc), and genuinely helpful.`
  );
  if(result){
    const posts=getBlogPosts();
    const titleMatch=result.match(/(?:SEO Title|Title)[:\s]*(.+)/i);
    const postTitle=titleMatch?titleMatch[1].trim():'AI Generated Post';
    posts.push({id:nextId(posts),title:postTitle,business:biz,keyword:kw1,
      status:'Review',wordCount:result.split(/\s+/).length,content:result,date:new Date().toISOString().slice(0,10)});
    saveBlogPosts(posts);

    // Parse social snippets from the generated content
    window._blogSocialSnippets={facebook:'',instagram:'',twitter:''};
    const fbMatch=result.match(/(?:Facebook)[:\s]*\n?([\s\S]*?)(?=\n\s*(?:Instagram|X\/Twitter|Twitter|$))/i);
    const igMatch=result.match(/(?:Instagram)[:\s]*\n?([\s\S]*?)(?=\n\s*(?:X\/Twitter|Twitter|$))/i);
    const twMatch=result.match(/(?:X\/Twitter|Twitter)[:\s]*\n?([\s\S]*?)(?=\n\s*(?:\d+\.|#{1,3}\s|$))/i);
    if(fbMatch) window._blogSocialSnippets.facebook=fbMatch[1].trim();
    if(igMatch) window._blogSocialSnippets.instagram=igMatch[1].trim();
    if(twMatch) window._blogSocialSnippets.twitter=twMatch[1].trim();
    window._blogPostTitle=postTitle;

    const socialSection=`<div style="margin-top:20px;border-top:1px solid var(--border);padding-top:16px">
      <h3 style="margin-bottom:12px"><i class="fas fa-share-alt"></i> Social Media Versions</h3>
      <div class="grid grid-3" style="gap:12px">
        <div class="card" style="padding:12px">
          <div style="font-weight:600;margin-bottom:8px;color:#1877f2"><i class="fab fa-facebook"></i> Facebook</div>
          <div id="social-fb" style="font-size:13px;white-space:pre-wrap;max-height:150px;overflow-y:auto">${window._blogSocialSnippets.facebook||'No Facebook snippet found'}</div>
          <button class="btn btn-ghost btn-sm mt-8" onclick="navigator.clipboard.writeText(document.getElementById('social-fb').innerText);toast('Facebook post copied!')"><i class="fas fa-copy"></i> Copy</button>
        </div>
        <div class="card" style="padding:12px">
          <div style="font-weight:600;margin-bottom:8px;color:#e4405f"><i class="fab fa-instagram"></i> Instagram</div>
          <div id="social-ig" style="font-size:13px;white-space:pre-wrap;max-height:150px;overflow-y:auto">${window._blogSocialSnippets.instagram||'No Instagram snippet found'}</div>
          <button class="btn btn-ghost btn-sm mt-8" onclick="navigator.clipboard.writeText(document.getElementById('social-ig').innerText);toast('Instagram post copied!')"><i class="fas fa-copy"></i> Copy</button>
        </div>
        <div class="card" style="padding:12px">
          <div style="font-weight:600;margin-bottom:8px;color:#1da1f2"><i class="fab fa-twitter"></i> X / Twitter</div>
          <div id="social-tw" style="font-size:13px;white-space:pre-wrap;max-height:150px;overflow-y:auto">${window._blogSocialSnippets.twitter||'No X/Twitter snippet found'}</div>
          <button class="btn btn-ghost btn-sm mt-8" onclick="navigator.clipboard.writeText(document.getElementById('social-tw').innerText);toast('X/Twitter post copied!')"><i class="fas fa-copy"></i> Copy</button>
        </div>
      </div>
    </div>`;

    showModal(`<h2><i class="fas fa-brain"></i> Generated Blog Post</h2>
      <div style="white-space:pre-wrap;line-height:1.7;max-height:45vh;overflow-y:auto" id="blog-output">${result}</div>
      ${socialSection}
      <div class="form-actions">
        <button class="btn btn-secondary" onclick="closeModal()">Close</button>
        <button class="btn btn-ghost" onclick="copyAsMarkdown()"><i class="fas fa-copy"></i> Copy Markdown</button>
        <button class="btn btn-primary" onclick="navigator.clipboard.writeText(document.getElementById('blog-output').innerText);toast('Copied!')"><i class="fas fa-copy"></i> Copy Text</button>
        <button class="btn btn-success" onclick="saveBlogSocialPosts()"><i class="fas fa-share-alt"></i> Save Social Posts</button>
      </div>`,'modal-xl');
    addActivity('Blog post generated: '+kw1,'seo');
  }
}

function copyAsMarkdown(){
  const el=document.getElementById('blog-output');
  if(el){navigator.clipboard.writeText(el.innerText);toast('Copied as markdown!')}
}

function saveBlogSocialPosts(){
  const snippets=window._blogSocialSnippets;
  if(!snippets){toast('No social snippets found','error');return}
  const posts=getSocialPosts();
  const today=new Date().toISOString().slice(0,10);
  const title=window._blogPostTitle||'Blog Post';
  let count=0;
  if(snippets.facebook){
    posts.push({id:nextId(posts),content:snippets.facebook,platform:'Facebook',status:'Draft',date:today,type:'Blog Repurpose',title:'FB: '+title});
    count++;
  }
  if(snippets.instagram){
    posts.push({id:nextId(posts),content:snippets.instagram,platform:'Instagram',status:'Draft',date:today,type:'Blog Repurpose',title:'IG: '+title});
    count++;
  }
  if(snippets.twitter){
    posts.push({id:nextId(posts),content:snippets.twitter,platform:'X/Twitter',status:'Draft',date:today,type:'Blog Repurpose',title:'X: '+title});
    count++;
  }
  if(count===0){toast('No social snippets to save','error');return}
  saveSocialPosts(posts);
  toast(count+' social post(s) saved as drafts!','success');
  addActivity('Saved '+count+' social posts from blog','social');
}

// Site Health Checklist
function renderSiteHealth(el){
  const items=['XML Sitemap submitted','Google Search Console connected','Google Business Profile optimized',
    'NAP consistent across directories','Mobile responsive verified','Page speed acceptable','SSL certificate active',
    'Schema markup implemented','Local business schema added','Service area pages for each city',
    'Image alt tags optimized','Internal linking structure solid','404 errors resolved','Redirect chains cleaned up','Core Web Vitals passing'];
  el.innerHTML=`<div class="grid grid-2">
    ${['GB','GC'].map(biz=>{
      const cl=getChecklist(biz);
      return `<div class="card"><div class="card-header"><span class="card-title">${biz==='GB'?'Green Bones':'Green Clean'} Site Health</span>
        <span class="text-sm text-muted">${Object.values(cl).filter(Boolean).length}/${items.length}</span></div>
        ${items.map((item,i)=>`<div class="checklist-item ${cl[i]?'checked':''}">
          <input type="checkbox" ${cl[i]?'checked':''} onchange="toggleChecklist('${biz}',${i},this.checked)">
          <label>${item}</label></div>`).join('')}
      </div>`}).join('')}
  </div>`;
}

function toggleChecklist(biz,idx,val){
  const cl=getChecklist(biz);cl[idx]=val;saveChecklist(biz,cl);
}

// Backlinks
function renderBacklinks(el){
  const bls=getBacklinks();
  el.innerHTML=`
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddBacklinkModal()"><i class="fas fa-plus"></i> Add Backlink</button>
      <button class="btn btn-warn" onclick="aiSuggestBacklinks()"><i class="fas fa-brain"></i> AI Suggest Opportunities</button>
    </div>
    <div class="card overflow-auto">
      <table><thead><tr><th>Source URL</th><th>Target</th><th>DA</th><th>Date</th><th>Status</th><th>Type</th><th>Actions</th></tr></thead>
      <tbody>${bls.map(b=>`<tr>
        <td class="text-sm">${b.sourceUrl||'-'}</td><td class="text-sm">${b.targetPage||'-'}</td>
        <td>${b.da||'-'}</td><td>${formatDate(b.date)}</td>
        <td><span class="badge ${b.status==='Active'?'badge-won':'badge-lost'}">${b.status}</span></td>
        <td>${b.type||'-'}</td>
        <td><button class="btn-icon" onclick="deleteBacklink(${b.id})"><i class="fas fa-trash"></i></button></td>
      </tr>`).join('')||'<tr><td colspan="7" class="text-muted">No backlinks tracked</td></tr>'}</tbody></table>
    </div>`;
}

function showAddBacklinkModal(){
  showModal(`<h2><i class="fas fa-link"></i> Add Backlink</h2>
    <div class="form-row">
      <div class="form-group"><label>Source URL</label><input id="bl-src"></div>
      <div class="form-group"><label>Target Page</label><input id="bl-tgt"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>DA</label><input id="bl-da" type="number"></div>
      <div class="form-group"><label>Type</label><select id="bl-type"><option>Guest Post</option><option>Directory</option><option>Citation</option><option>Social</option><option>Other</option></select></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addBacklink()">Add</button></div>`);
}

function addBacklink(){
  const bls=getBacklinks();
  bls.push({id:nextId(bls),sourceUrl:document.getElementById('bl-src').value,targetPage:document.getElementById('bl-tgt').value,
    da:parseInt(document.getElementById('bl-da').value)||0,type:document.getElementById('bl-type').value,
    date:new Date().toISOString().slice(0,10),status:'Active'});
  saveBacklinks(bls);closeModal();toast('Backlink added');renderSEO(document.getElementById('main'));
}

function deleteBacklink(id){
  if(!confirm('Delete?'))return;
  saveBacklinks(getBacklinks().filter(b=>b.id!==id));toast('Deleted');renderSEO(document.getElementById('main'));
}

async function aiSuggestBacklinks(){
  toast('Generating backlink ideas...','info');
  const result=await callClaude(
    'You are a local SEO link building expert for the Yuba-Sutter area in Northern California.',
    'Suggest 15 specific, actionable backlink opportunities for:\n1. Green Bones Pest Control (Yuba City)\n2. Green Clean Disinfectants (Yuba City)\n\nInclude: local directories, community organizations, partnerships, guest posting targets, local news, and industry-specific directories. Be specific to the Yuba-Sutter area.'
  );
  if(result) showModal(`<h2><i class="fas fa-brain"></i> Backlink Opportunities</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// ==================== MODULE 4: SOCIAL MEDIA ====================
let socialTab='calendar';

function renderSocial(el){
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-share-nodes" style="color:var(--accent-light)"></i> Social Media Command Center</h1><p>Content creation, scheduling, and performance</p></div>
    <div class="tabs">
      <div class="tab ${socialTab==='calendar'?'active':''}" onclick="socialTab='calendar';renderSocial(document.getElementById('main'))">Calendar</div>
      <div class="tab ${socialTab==='generate'?'active':''}" onclick="socialTab='generate';renderSocial(document.getElementById('main'))">Content Generator</div>
      <div class="tab ${socialTab==='repurpose'?'active':''}" onclick="socialTab='repurpose';renderSocial(document.getElementById('main'))">Blog Repurposer</div>
      <div class="tab ${socialTab==='engagement'?'active':''}" onclick="socialTab='engagement';renderSocial(document.getElementById('main'))">Engagement</div>
      <div class="tab ${socialTab==='hashtags'?'active':''}" onclick="socialTab='hashtags';renderSocial(document.getElementById('main'))">Hashtags</div>
    </div>
    <div id="social-content"></div>`;
  const c=document.getElementById('social-content');
  if(socialTab==='calendar') renderSocialCalendar(c);
  else if(socialTab==='generate') renderContentGenerator(c);
  else if(socialTab==='repurpose') renderRepurposer(c);
  else if(socialTab==='engagement') renderEngagementTracker(c);
  else if(socialTab==='hashtags') renderHashtags(c);
}

function renderSocialCalendar(el){
  const posts=getSocialPosts();
  const today=new Date();
  const startOfWeek=new Date(today);
  startOfWeek.setDate(today.getDate()-today.getDay()+(calendarWeekOffset*7));
  const endOfWeek=new Date(startOfWeek);endOfWeek.setDate(startOfWeek.getDate()+6);
  const days=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
  const platformColors={Facebook:'#1877F2',Instagram:'#E4405F','X/Twitter':'#1DA1F2',TikTok:'#000',Nextdoor:'#8ED500','Google Business Profile':'#4285F4'};
  const monthNames=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
  const rangeLabel=`${monthNames[startOfWeek.getMonth()]} ${startOfWeek.getDate()} - ${monthNames[endOfWeek.getMonth()]} ${endOfWeek.getDate()}, ${endOfWeek.getFullYear()}`;
  const platforms=CONFIG.platforms||['Facebook','Instagram','X/Twitter','TikTok','Nextdoor','Google Business Profile'];
  el.innerHTML=`
    <div class="toolbar" style="justify-content:space-between">
      <button class="btn btn-primary" onclick="showAddSocialPostModal()"><i class="fas fa-plus"></i> Add Post</button>
      <div style="display:flex;align-items:center;gap:12px">
        <button class="btn btn-icon" onclick="calendarWeekOffset--;renderSocialCalendar(document.getElementById('social-content'))" title="Previous week"><i class="fas fa-chevron-left"></i></button>
        <span style="font-weight:600;min-width:180px;text-align:center">${rangeLabel}</span>
        <button class="btn btn-icon" onclick="calendarWeekOffset++;renderSocialCalendar(document.getElementById('social-content'))" title="Next week"><i class="fas fa-chevron-right"></i></button>
        <button class="btn btn-sm btn-ghost" onclick="calendarWeekOffset=0;renderSocialCalendar(document.getElementById('social-content'))" title="Today">Today</button>
      </div>
    </div>
    <div class="cal-week">
      ${days.map((d,i)=>{
        const date=new Date(startOfWeek);date.setDate(startOfWeek.getDate()+i);
        const dateStr=date.toISOString().slice(0,10);
        const isToday=dateStr===new Date().toISOString().slice(0,10);
        const dayPosts=posts.filter(p=>p.date===dateStr);
        const grouped={};dayPosts.forEach(p=>{if(!grouped[p.platform])grouped[p.platform]=[];grouped[p.platform].push(p)});
        return `<div class="cal-day" style="${isToday?'border:1px solid var(--accent);':''}">
          <div class="cal-day-header" style="${isToday?'color:var(--accent-light);':''}"><strong>${d}</strong> ${date.getDate()}</div>
          ${platforms.map(plat=>{
            const platPosts=grouped[plat]||[];
            if(!platPosts.length)return '';
            return `<div class="cal-platform-row" style="margin-bottom:4px">
              <div style="font-size:9px;font-weight:700;color:${platformColors[plat]||'#666'};text-transform:uppercase;margin-bottom:2px;letter-spacing:.3px">${plat.replace('Google Business Profile','GBP')}</div>
              ${platPosts.map(p=>`<div class="cal-event" style="border-color:${platformColors[p.platform]||'#666'}" onclick="showSocialPostDetail(${p.id})">
                <span class="text-xs text-muted">${(p.content||'').slice(0,35)}${(p.content||'').length>35?'...':''}</span>
                <span style="font-size:9px;opacity:.7;margin-left:4px">${p.status||''}</span>
              </div>`).join('')}
            </div>`}).join('')}
        </div>`}).join('')}
    </div>`;
}

function showAddSocialPostModal(){
  showModal(`<h2><i class="fas fa-pen"></i> Add Social Post</h2>
    <div class="form-row">
      <div class="form-group"><label>Platform</label><select id="sp-plat">${CONFIG.platforms.map(p=>`<option>${p}</option>`).join('')}</select></div>
      <div class="form-group"><label>Business</label><select id="sp-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option><option>Both</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Date</label><input id="sp-date" type="date" value="${new Date().toISOString().slice(0,10)}"></div>
      <div class="form-group"><label>Status</label><select id="sp-stat"><option>Draft</option><option>Approved</option><option>Posted</option></select></div>
    </div>
    <div class="form-group"><label>Content</label><textarea id="sp-content" rows="4"></textarea></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addSocialPost()">Add</button></div>`);
}

function addSocialPost(){
  const posts=getSocialPosts();
  posts.push({id:nextId(posts),platform:document.getElementById('sp-plat').value,business:document.getElementById('sp-biz').value,
    date:document.getElementById('sp-date').value,status:document.getElementById('sp-stat').value,
    content:document.getElementById('sp-content').value});
  saveSocialPosts(posts);closeModal();toast('Post added');renderSocial(document.getElementById('main'));
}

function showSocialPostDetail(id){
  const p=getSocialPosts().find(x=>x.id===id);if(!p)return;
  showModal(`<h2>${p.platform} Post</h2>
    <div class="form-row">
      <div class="form-group"><label>Status</label><select id="spd-stat">${['Draft','Approved','Posted'].map(s=>`<option ${s===p.status?'selected':''}>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Date</label><input id="spd-date" type="date" value="${p.date||''}"></div>
    </div>
    <div class="form-group"><label>Content</label><textarea id="spd-content" rows="6">${p.content||''}</textarea></div>
    <div class="form-actions">
      <button class="btn btn-danger btn-sm" onclick="deleteSocialPost(${id})">Delete</button>
      <button class="btn btn-secondary" onclick="closeModal()">Cancel</button>
      <button class="btn btn-primary" onclick="saveSocialPost(${id})">Save</button>
    </div>`);
}

function saveSocialPost(id){
  const posts=getSocialPosts();const idx=posts.findIndex(x=>x.id===id);if(idx<0)return;
  posts[idx].status=document.getElementById('spd-stat').value;
  posts[idx].date=document.getElementById('spd-date').value;
  posts[idx].content=document.getElementById('spd-content').value;
  saveSocialPosts(posts);closeModal();toast('Saved');renderSocial(document.getElementById('main'));
}

function deleteSocialPost(id){
  if(!confirm('Delete?'))return;
  saveSocialPosts(getSocialPosts().filter(p=>p.id!==id));closeModal();toast('Deleted');renderSocial(document.getElementById('main'));
}

// Content Generator
function renderContentGenerator(el){
  el.innerHTML=`
    <div class="card">
      <div class="card-header"><span class="card-title"><i class="fas fa-brain"></i> AI Content Generator</span></div>
      <p class="text-muted mb-16">Generate content for ALL platforms from a single idea</p>
      <div class="form-row">
        <div class="form-group"><label>Business</label><select id="cg-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option><option>Both</option></select></div>
        <div class="form-group"><label>Content Type</label><select id="cg-type"><option>Educational</option><option>Promotional</option><option>Seasonal</option><option>Behind-the-Scenes</option><option>Customer Testimonial</option><option>Local Community</option><option>Tip of the Week</option><option>Before-After</option><option>Emergency/Urgent</option></select></div>
      </div>
      <div class="form-row">
        <div class="form-group"><label>Tone</label><select id="cg-tone"><option>Professional</option><option>Friendly</option><option>Urgent</option><option>Humorous</option><option>Neighborly</option></select></div>
        <div class="form-group"><label>Topic</label><input id="cg-topic" placeholder="e.g., Spring ant prevention tips"></div>
      </div>
      <div class="form-group"><label>Special Instructions</label><textarea id="cg-instructions" rows="2" placeholder="Any specific angle, offer, or detail to include..."></textarea></div>
      <button class="btn btn-primary" onclick="generateAllPlatforms()" style="width:100%;padding:12px"><i class="fas fa-wand-magic-sparkles"></i> Generate All Platforms</button>
    </div>
    <div id="cg-output"></div>`;
}

async function generateAllPlatforms(){
  const biz=document.getElementById('cg-biz').value;
  const type=document.getElementById('cg-type').value;
  const tone=document.getElementById('cg-tone').value;
  const topic=document.getElementById('cg-topic').value;
  const instr=document.getElementById('cg-instructions').value;
  const output=document.getElementById('cg-output');
  output.innerHTML='<div class="card mt-16 relative" style="min-height:200px"><div class="loading-overlay"><div class="spinner"></div><div>Generating content for 6 platforms...</div></div></div>';
  const result=await callClaude(
    `You are an expert social media content creator for ${biz} in Yuba City, California. Create engaging, platform-optimized content.`,
    `Generate social media content for ALL 6 platforms:\n\nBusiness: ${biz}\nContent Type: ${type}\nTone: ${tone}\nTopic: ${topic}\nSpecial Instructions: ${instr||'None'}\n\nGenerate:\n1. **FACEBOOK** (150-300 words, engaging, CTA, emojis OK)\n2. **INSTAGRAM** (punchy caption + 20-30 relevant local hashtags + CTA)\n3. **X/TWITTER** (under 280 chars, hook-driven, 3-5 hashtags)\n4. **TIKTOK SCRIPT** (hook in first 3 seconds, 15/30/60 sec options)\n5. **NEXTDOOR** (community-focused, neighborly, local references to Yuba City/Marysville)\n6. **GOOGLE BUSINESS PROFILE** (concise, service-focused)\n\nSeparate each with a clear header. Make each feel native to that platform.`
  );
  if(result){
    const sections=result.split(/(?=\*\*(?:FACEBOOK|INSTAGRAM|X\/TWITTER|TIKTOK|NEXTDOOR|GOOGLE))/i);
    output.innerHTML=`<div class="grid grid-2 mt-16 gap-16">
      ${sections.filter(s=>s.trim()).map((s,i)=>{
        const platformMatch=s.match(/\*\*(.*?)\*\*/);
        const platform=platformMatch?platformMatch[1]:'Platform '+(i+1);
        return `<div class="card">
          <div class="card-header"><span class="card-title">${platform}</span>
            <div class="flex gap-8">
              <button class="btn btn-sm btn-ghost" onclick="navigator.clipboard.writeText(this.closest('.card').querySelector('.post-content').innerText);toast('Copied!')"><i class="fas fa-copy"></i></button>
              <button class="btn btn-sm btn-success" onclick="approveGeneratedPost('${platform}',this.closest('.card').querySelector('.post-content').innerText)"><i class="fas fa-check"></i> Approve</button>
            </div>
          </div>
          <div class="post-content text-sm" style="white-space:pre-wrap;line-height:1.6">${s.trim()}</div>
        </div>`}).join('')}
    </div>`;
    addActivity(`Social content generated: ${topic}`,'social');
  }
}

function approveGeneratedPost(platform,content){
  const posts=getSocialPosts();
  const platMap={'FACEBOOK':'Facebook','INSTAGRAM':'Instagram','X/TWITTER':'X/Twitter','TIKTOK':'TikTok','NEXTDOOR':'Nextdoor','GOOGLE BUSINESS PROFILE':'Google Business Profile'};
  posts.push({id:nextId(posts),platform:platMap[platform.toUpperCase()]||platform,
    business:document.getElementById('cg-biz').value,date:new Date().toISOString().slice(0,10),
    status:'Approved',content:content});
  saveSocialPosts(posts);toast('Post approved and added to calendar');
}

// Repurposer
function renderRepurposer(el){
  const posts=getBlogPosts().filter(p=>p.status==='Published'||p.content);
  el.innerHTML=`<div class="card">
    <div class="card-header"><span class="card-title"><i class="fas fa-recycle"></i> Blog-to-Social Repurposer</span></div>
    <div class="form-group"><label>Select Blog Post</label><select id="rep-post">
      ${posts.map(p=>`<option value="${p.id}">${p.title} (${p.status})</option>`).join('')||'<option>No blog posts available</option>'}
    </select></div>
    <button class="btn btn-primary" onclick="repurposeBlog()"><i class="fas fa-brain"></i> Repurpose to All Platforms</button>
    <div id="rep-output" class="mt-16"></div>
  </div>`;
}

async function repurposeBlog(){
  const postId=parseInt(document.getElementById('rep-post').value);
  const post=getBlogPosts().find(p=>p.id===postId);if(!post){toast('Select a post','error');return}
  document.getElementById('rep-output').innerHTML='<div class="relative" style="min-height:100px"><div class="loading-overlay"><div class="spinner"></div><div>Repurposing...</div></div></div>';
  const result=await callClaude(
    'You are a social media content expert. Repurpose blog content into platform-native social posts.',
    `Repurpose this blog post into content for 6 platforms:\n\nTitle: ${post.title}\nContent: ${(post.content||'').slice(0,3000)}\n\nGenerate: Facebook, Instagram (with hashtags), X/Twitter, TikTok Script, Nextdoor (Yuba City/Marysville focused), Google Business Profile. Each should feel native to that platform.`
  );
  if(result){
    document.getElementById('rep-output').innerHTML=`<div style="white-space:pre-wrap;line-height:1.7;background:rgba(0,0,0,.2);padding:16px;border-radius:var(--radius)">${result}</div>
      <button class="btn btn-ghost mt-8" onclick="navigator.clipboard.writeText(document.getElementById('rep-output').querySelector('div').innerText);toast('Copied!')"><i class="fas fa-copy"></i> Copy All</button>`;
  }
}

// Engagement Tracker
function renderEngagementTracker(el){
  const eng=getEngagement();
  el.innerHTML=`
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddEngagementModal()"><i class="fas fa-plus"></i> Add Entry</button>
      <button class="btn btn-warn" onclick="aiAnalyzeEngagement()"><i class="fas fa-brain"></i> AI Analyze Performance</button>
    </div>
    <div class="card overflow-auto">
      <table><thead><tr><th>Platform</th><th>Date</th><th>Reach</th><th>Likes</th><th>Comments</th><th>Shares</th><th>Clicks</th><th>Leads</th><th>Actions</th></tr></thead>
      <tbody>${eng.map(e=>`<tr>
        <td>${e.platform}</td><td>${formatDate(e.date)}</td><td>${e.reach||0}</td><td>${e.likes||0}</td>
        <td>${e.comments||0}</td><td>${e.shares||0}</td><td>${e.clicks||0}</td><td>${e.leads||0}</td>
        <td><button class="btn-icon" onclick="deleteEngagement(${e.id})"><i class="fas fa-trash"></i></button></td>
      </tr>`).join('')||'<tr><td colspan="9" class="text-muted">No engagement data</td></tr>'}</tbody></table>
    </div>
    <div class="card mt-16"><canvas id="chart-engagement" height="250"></canvas></div>`;
  // Chart
  if(eng.length){
    const platforms=[...new Set(eng.map(e=>e.platform))];
    const colors=['#1877F2','#E4405F','#1DA1F2','#000','#8ED500','#4285F4'];
    createChart('chart-engagement',{type:'bar',data:{
      labels:platforms,
      datasets:[
        {label:'Reach',data:platforms.map(p=>eng.filter(e=>e.platform===p).reduce((s,e)=>s+(e.reach||0),0)),backgroundColor:'rgba(59,130,246,.7)'},
        {label:'Clicks',data:platforms.map(p=>eng.filter(e=>e.platform===p).reduce((s,e)=>s+(e.clicks||0),0)),backgroundColor:'rgba(245,158,11,.7)'},
        {label:'Leads',data:platforms.map(p=>eng.filter(e=>e.platform===p).reduce((s,e)=>s+(e.leads||0),0)),backgroundColor:'rgba(34,197,94,.7)'}
      ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});
  }
}

function showAddEngagementModal(){
  showModal(`<h2>Add Engagement Data</h2>
    <div class="form-row">
      <div class="form-group"><label>Platform</label><select id="eng-plat">${CONFIG.platforms.map(p=>`<option>${p}</option>`).join('')}</select></div>
      <div class="form-group"><label>Date</label><input id="eng-date" type="date" value="${new Date().toISOString().slice(0,10)}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Reach</label><input id="eng-reach" type="number" value="0"></div>
      <div class="form-group"><label>Likes</label><input id="eng-likes" type="number" value="0"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Comments</label><input id="eng-comments" type="number" value="0"></div>
      <div class="form-group"><label>Shares</label><input id="eng-shares" type="number" value="0"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Clicks</label><input id="eng-clicks" type="number" value="0"></div>
      <div class="form-group"><label>Leads Generated</label><input id="eng-leads" type="number" value="0"></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addEngagement()">Add</button></div>`);
}

function addEngagement(){
  const eng=getEngagement();
  eng.push({id:nextId(eng),platform:document.getElementById('eng-plat').value,date:document.getElementById('eng-date').value,
    reach:parseInt(document.getElementById('eng-reach').value)||0,likes:parseInt(document.getElementById('eng-likes').value)||0,
    comments:parseInt(document.getElementById('eng-comments').value)||0,shares:parseInt(document.getElementById('eng-shares').value)||0,
    clicks:parseInt(document.getElementById('eng-clicks').value)||0,leads:parseInt(document.getElementById('eng-leads').value)||0});
  saveEngagement(eng);closeModal();toast('Added');renderSocial(document.getElementById('main'));
}

function deleteEngagement(id){
  saveEngagement(getEngagement().filter(e=>e.id!==id));toast('Deleted');renderSocial(document.getElementById('main'));
}

async function aiAnalyzeEngagement(){
  const eng=getEngagement();
  if(!eng.length){toast('No data to analyze','error');return}
  toast('Analyzing...','info');
  const result=await callClaude('You analyze social media performance for small businesses.',
    `Analyze this social media engagement data and give specific recommendations:\n${JSON.stringify(eng)}\n\nProvide: 1) Best performing platform 2) Content type insights 3) Posting time recommendations 4) Specific improvement strategies`);
  if(result) showModal(`<h2><i class="fas fa-brain"></i> Engagement Analysis</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// Hashtags
function renderHashtags(el){
  const tags=DB.get('hashtags',{pest:[],clean:[],local:[],seasonal:[]});
  el.innerHTML=`<div class="card">
    <div class="card-header"><span class="card-title">Hashtag Library</span>
      <button class="btn btn-warn btn-sm" onclick="aiGenerateHashtags()"><i class="fas fa-brain"></i> AI Generate</button></div>
    ${Object.entries(tags).map(([cat,list])=>`<div class="mb-16">
      <div class="section-title">${cat.charAt(0).toUpperCase()+cat.slice(1)}</div>
      <div>${list.map(t=>`<span class="season-tag">#${t}</span>`).join(' ')||'<span class="text-muted">No hashtags yet</span>'}</div>
      <div class="mt-8"><input placeholder="Add hashtag..." onkeydown="if(event.key==='Enter'){addHashtag('${cat}',this.value);this.value=''};" style="width:200px"></div>
    </div>`).join('')}
  </div>`;
}

function addHashtag(cat,tag){
  if(!tag)return;
  const tags=DB.get('hashtags',{pest:[],clean:[],local:[],seasonal:[]});
  if(!tags[cat])tags[cat]=[];
  tags[cat].push(tag.replace('#',''));
  DB.set('hashtags',tags);renderSocial(document.getElementById('main'));
}

async function aiGenerateHashtags(){
  toast('Generating hashtags...','info');
  const result=await callClaude('You are a social media hashtag expert.',
    'Generate categorized hashtags for Green Bones Pest Control and Green Clean Disinfectants in Yuba City CA.\n\nCategories: Pest Control, Disinfection/Cleaning, Local Area, Seasonal.\n20 hashtags per category. Focus on discoverability and local reach.');
  if(result) showModal(`<h2>Generated Hashtags</h2><div style="white-space:pre-wrap">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// ==================== MODULE 5: VIDEO & AD CAMPAIGNS ====================
let videoTab='campaigns';

function renderVideo(el){
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-video" style="color:var(--accent-light)"></i> Video & Ad Campaign Manager</h1></div>
    <div class="tabs">
      <div class="tab ${videoTab==='campaigns'?'active':''}" onclick="videoTab='campaigns';renderVideo(document.getElementById('main'))">Campaigns</div>
      <div class="tab ${videoTab==='script'?'active':''}" onclick="videoTab='script';renderVideo(document.getElementById('main'))">Script Generator</div>
      <div class="tab ${videoTab==='adperf'?'active':''}" onclick="videoTab='adperf';renderVideo(document.getElementById('main'))">Ad Performance</div>
      <div class="tab ${videoTab==='tiktok'?'active':''}" onclick="videoTab='tiktok';renderVideo(document.getElementById('main'))">TikTok Strategy</div>
    </div>
    <div id="video-content"></div>`;
  const c=document.getElementById('video-content');
  if(videoTab==='campaigns') renderCampaigns(c);
  else if(videoTab==='script') renderScriptGenerator(c);
  else if(videoTab==='adperf') renderAdPerformance(c);
  else if(videoTab==='tiktok') renderTikTokStrategy(c);
}

const campaignStages=['Planning','Script','Voiceover','Editing','Published'];

function moveCampaignNext(id,e){
  e.stopPropagation();
  const camps=getCampaigns();const idx=camps.findIndex(x=>x.id===id);if(idx<0)return;
  const cur=campaignStages.indexOf(camps[idx].status);
  if(cur<0||cur>=campaignStages.length-1)return;
  camps[idx].status=campaignStages[cur+1];
  saveCampaigns(camps);toast('Moved to '+camps[idx].status);renderVideo(document.getElementById('main'));
}

function renderCampaigns(el){
  const camps=getCampaigns();
  el.innerHTML=`
    <div class="toolbar"><button class="btn btn-primary" onclick="showAddCampaignModal()"><i class="fas fa-plus"></i> Add Campaign</button></div>
    <div class="kanban">
      ${campaignStages.map(s=>{
        const items=camps.filter(c=>c.status===s);
        return `<div class="kanban-col"><div class="kanban-col-title">${s} <span class="count">${items.length}</span></div>
          ${items.map(c=>`<div class="kanban-card" onclick="showCampaignDetail(${c.id})">
            <div class="card-brand ${c.business&&c.business.includes('Bones')?'gb':'gc'}">${c.business&&c.business.includes('Bones')?'GB':'GC'}</div>
            <div style="font-weight:600;font-size:13px">${c.title}</div>
            <div class="text-xs text-muted">${c.business||''}</div>
            <div class="text-xs text-muted">${c.platform||''} · ${c.duration||''}s</div>
            <div style="margin-top:6px;display:flex;justify-content:space-between;align-items:center">
              <span class="badge" style="font-size:10px">${s}</span>
              ${s!=='Published'?`<button class="btn btn-sm btn-primary" onclick="moveCampaignNext(${c.id},event)" title="Move to ${campaignStages[campaignStages.indexOf(s)+1]||''}"><i class="fas fa-arrow-right"></i> Next</button>`:''}
            </div>
          </div>`).join('')}
        </div>`}).join('')}
    </div>`;
}

function showAddCampaignModal(){
  showModal(`<h2><i class="fas fa-film"></i> Add Campaign</h2>
    <div class="form-row">
      <div class="form-group"><label>Title</label><input id="cp-title"></div>
      <div class="form-group"><label>Business</label><select id="cp-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Platform</label><select id="cp-plat"><option>TikTok</option><option>Facebook</option><option>Instagram</option><option>YouTube</option></select></div>
      <div class="form-group"><label>Duration</label><select id="cp-dur"><option value="15">15s</option><option value="30">30s</option><option value="60">60s</option></select></div>
    </div>
    <div class="form-group"><label>Script</label><textarea id="cp-script" rows="4"></textarea></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addCampaign()">Add</button></div>`);
}

function addCampaign(){
  const camps=getCampaigns();
  camps.push({id:nextId(camps),title:document.getElementById('cp-title').value,business:document.getElementById('cp-biz').value,
    platform:document.getElementById('cp-plat').value,duration:document.getElementById('cp-dur').value,
    script:document.getElementById('cp-script').value,status:'Planning',views:0,clicks:0,leads:0});
  saveCampaigns(camps);closeModal();toast('Campaign added');renderVideo(document.getElementById('main'));
}

function showCampaignDetail(id){
  const c=getCampaigns().find(x=>x.id===id);if(!c)return;
  showModal(`<h2>${c.title}</h2>
    <div class="form-row">
      <div class="form-group"><label>Status</label><select id="cpd-status">${campaignStages.map(s=>`<option ${s===c.status?'selected':''}>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>Platform</label><select id="cpd-plat">${['TikTok','Facebook','Instagram','YouTube'].map(p=>`<option ${p===c.platform?'selected':''}>${p}</option>`).join('')}</select></div>
    </div>
    <div class="form-group"><label>Script</label><textarea id="cpd-script" rows="6">${c.script||''}</textarea></div>
    <div class="form-row">
      <div class="form-group"><label>Views</label><input id="cpd-views" type="number" value="${c.views||0}"></div>
      <div class="form-group"><label>Clicks</label><input id="cpd-clicks" type="number" value="${c.clicks||0}"></div>
      <div class="form-group"><label>Leads</label><input id="cpd-leads" type="number" value="${c.leads||0}"></div>
    </div>
    <div class="form-actions">
      <button class="btn btn-danger btn-sm" onclick="deleteCampaign(${id})">Delete</button>
      <button class="btn btn-secondary" onclick="closeModal()">Cancel</button>
      <button class="btn btn-primary" onclick="saveCampaignDetail(${id})">Save</button>
    </div>`);
}

function saveCampaignDetail(id){
  const camps=getCampaigns();const idx=camps.findIndex(x=>x.id===id);if(idx<0)return;
  camps[idx].status=document.getElementById('cpd-status').value;
  camps[idx].platform=document.getElementById('cpd-plat').value;
  camps[idx].script=document.getElementById('cpd-script').value;
  camps[idx].views=parseInt(document.getElementById('cpd-views').value)||0;
  camps[idx].clicks=parseInt(document.getElementById('cpd-clicks').value)||0;
  camps[idx].leads=parseInt(document.getElementById('cpd-leads').value)||0;
  saveCampaigns(camps);closeModal();toast('Saved');renderVideo(document.getElementById('main'));
}

function deleteCampaign(id){
  if(!confirm('Delete?'))return;
  saveCampaigns(getCampaigns().filter(c=>c.id!==id));closeModal();toast('Deleted');renderVideo(document.getElementById('main'));
}

// Script Generator
function updateScriptServices(){
  const biz=document.getElementById('vs-biz').value;
  const svcs=biz.includes('Bones')?CONFIG.gbServices:CONFIG.gcServices;
  const sel=document.getElementById('vs-svc');
  sel.innerHTML=svcs.map(s=>`<option>${s}</option>`).join('');
}

function renderScriptGenerator(el){
  el.innerHTML=`<div class="card">
    <div class="card-header"><span class="card-title"><i class="fas fa-brain"></i> AI Video Script Generator</span></div>
    <div class="form-row">
      <div class="form-group"><label>Business</label><select id="vs-biz" onchange="updateScriptServices()"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
      <div class="form-group"><label>Service to Promote</label><select id="vs-svc">${CONFIG.gbServices.map(s=>`<option>${s}</option>`).join('')}</select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Target Audience</label><select id="vs-aud"><option>Homeowners</option><option>Commercial</option><option>Renters</option><option>Landlords</option><option>Property Managers</option></select></div>
      <div class="form-group"><label>Duration</label><select id="vs-dur"><option>15</option><option>30</option><option selected>60</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Style</label><select id="vs-style"><option>Problem-Solution</option><option>Testimonial</option><option>Educational</option><option>Seasonal Urgency</option><option>Before-After</option><option>Day-in-the-Life</option></select></div>
      <div class="form-group"><label>Hook Type</label><select id="vs-hook"><option>Question</option><option>Shocking Fact</option><option>Pain Point</option><option>Visual Surprise</option></select></div>
    </div>
    <div class="form-group"><label>CTA</label><select id="vs-cta"><option>Call Now</option><option>Book Online</option><option>Free Quote</option><option>Limited Offer</option></select></div>
    <button class="btn btn-primary w-full mt-8" onclick="generateScript()"><i class="fas fa-wand-magic-sparkles"></i> Generate Script</button>
    <div id="vs-output" class="mt-16"></div>
  </div>`;
}

async function generateScript(){
  const output=document.getElementById('vs-output');
  output.innerHTML='<div class="relative" style="min-height:100px"><div class="loading-overlay"><div class="spinner"></div><div>Writing script...</div></div></div>';
  const result=await callClaude(
    'You are an expert video ad scriptwriter for local service businesses.',
    `Write a professional video ad script:\nBusiness: ${document.getElementById('vs-biz').value}\nService: ${document.getElementById('vs-svc').value}\nTarget Audience: ${document.getElementById('vs-aud').value}\nDuration: ${document.getElementById('vs-dur').value} seconds\nStyle: ${document.getElementById('vs-style').value}\nHook Type: ${document.getElementById('vs-hook').value}\nCTA: ${document.getElementById('vs-cta').value}\nLocation: Yuba City, CA area (Yuba-Sutter region)\n\nProvide ALL of the following clearly labeled sections:\n\n1. HOOK (first 3 seconds) - The attention-grabbing opener using the specified hook type. Must stop the scroll immediately.\n\n2. FULL SCRIPT WITH TIMING - Complete script with [00:00] timing markers for every line/scene. Include speaker directions, pauses, and transitions.\n\n3. B-ROLL SHOT LIST - Numbered list of every B-roll shot needed, with description, duration, and camera angle/movement suggestions.\n\n4. TEXT OVERLAYS - Every text overlay that should appear on screen, with exact timing, position suggestion (top/center/bottom), font style recommendation, and animation type.\n\n5. MUSIC & SOUND RECOMMENDATIONS - Specific music genre/mood/tempo for each section, plus sound effects (whoosh, ding, etc.) with timing.\n\n6. VOICEOVER DIRECTION - Tone, pacing, emphasis words, emotional beats, and any character voice notes for the VO artist.`
  );
  if(result){
    output.innerHTML=`<div style="white-space:pre-wrap;line-height:1.7;background:rgba(0,0,0,.2);padding:16px;border-radius:var(--radius)">${result}</div>
      <button class="btn btn-ghost mt-8" onclick="navigator.clipboard.writeText(document.getElementById('vs-output').querySelector('div').innerText);toast('Copied!')"><i class="fas fa-copy"></i> Copy</button>`;
    addActivity('Video script generated','video');
  }
}

// Ad Performance
function renderAdPerformance(el){
  const ads=getAdPerf();
  const totalSpend=ads.reduce((s,a)=>s+(a.spend||0),0);
  const totalClicks=ads.reduce((s,a)=>s+(a.clicks||0),0);
  const totalImpressions=ads.reduce((s,a)=>s+(a.impressions||0),0);
  const totalLeads=ads.reduce((s,a)=>s+(a.leads||0),0);
  const totalRevenue=ads.reduce((s,a)=>s+(a.revenue||0),0);
  const avgCTR=totalImpressions?(totalClicks/totalImpressions*100).toFixed(2):0;
  const avgCPL=totalLeads?(totalSpend/totalLeads).toFixed(2):0;
  const overallROAS=totalSpend?(totalRevenue/totalSpend).toFixed(2):0;
  el.innerHTML=`
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddAdModal()"><i class="fas fa-plus"></i> Add Campaign Data</button>
      <button class="btn btn-warn" onclick="aiAnalyzeAds()"><i class="fas fa-brain"></i> Analyze Campaigns</button>
    </div>
    <div class="grid grid-4 mb-16">
      <div class="kpi-card card"><div class="kpi-icon"><i class="fas fa-dollar-sign"></i></div><div class="kpi-value">$${totalSpend.toLocaleString()}</div><div class="kpi-label">Total Spend</div></div>
      <div class="kpi-card card"><div class="kpi-icon"><i class="fas fa-mouse-pointer"></i></div><div class="kpi-value">${avgCTR}%</div><div class="kpi-label">Avg CTR</div></div>
      <div class="kpi-card card"><div class="kpi-icon"><i class="fas fa-user-plus"></i></div><div class="kpi-value">$${avgCPL}</div><div class="kpi-label">Cost Per Lead</div></div>
      <div class="kpi-card card"><div class="kpi-icon"><i class="fas fa-chart-line"></i></div><div class="kpi-value ${overallROAS>=2?'text-success':overallROAS>=1?'text-warn':'text-danger'}">${overallROAS}x</div><div class="kpi-label">Overall ROAS</div></div>
    </div>
    <div class="card overflow-auto">
      <table><thead><tr><th>Campaign</th><th>Platform</th><th>Spend</th><th>Impressions</th><th>Clicks</th><th>CTR</th><th>Leads</th><th>CPL</th><th>Revenue</th><th>ROAS</th><th>Actions</th></tr></thead>
      <tbody>${ads.map(a=>{
        const ctr=a.impressions?(a.clicks/a.impressions*100).toFixed(2):0;
        const cpl=a.leads?(a.spend/a.leads).toFixed(2):0;
        const roas=a.spend?(a.revenue/a.spend).toFixed(2):0;
        return `<tr><td>${a.name}</td><td>${a.platform}</td><td>$${a.spend||0}</td><td>${(a.impressions||0).toLocaleString()}</td>
          <td>${a.clicks||0}</td><td>${ctr}%</td><td>${a.leads||0}</td><td>$${cpl}</td><td>$${a.revenue||0}</td>
          <td class="${roas>=2?'text-success':roas>=1?'text-warn':'text-danger'}">${roas}x</td>
          <td><button class="btn-icon" onclick="deleteAdPerf(${a.id})"><i class="fas fa-trash"></i></button></td></tr>`}).join('')||'<tr><td colspan="11" class="text-muted">No ad data</td></tr>'}</tbody></table>
    </div>`;
}

function deleteAdPerf(id){
  if(!confirm('Delete this campaign data?'))return;
  saveAdPerf(getAdPerf().filter(a=>a.id!==id));toast('Deleted');renderVideo(document.getElementById('main'));
}

function showAddAdModal(){
  showModal(`<h2>Add Ad Campaign Data</h2>
    <div class="form-row">
      <div class="form-group"><label>Campaign Name</label><input id="ad-name"></div>
      <div class="form-group"><label>Platform</label><select id="ad-plat"><option>Facebook</option><option>Instagram</option><option>TikTok</option><option>Google</option><option>YouTube</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Spend ($)</label><input id="ad-spend" type="number"></div>
      <div class="form-group"><label>Impressions</label><input id="ad-imp" type="number"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Clicks</label><input id="ad-clicks" type="number"></div>
      <div class="form-group"><label>Leads</label><input id="ad-leads" type="number"></div>
    </div>
    <div class="form-group"><label>Revenue Generated ($)</label><input id="ad-rev" type="number"></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addAdPerf()">Add</button></div>`);
}

function addAdPerf(){
  const ads=getAdPerf();
  ads.push({id:nextId(ads),name:document.getElementById('ad-name').value,platform:document.getElementById('ad-plat').value,
    spend:parseFloat(document.getElementById('ad-spend').value)||0,impressions:parseInt(document.getElementById('ad-imp').value)||0,
    clicks:parseInt(document.getElementById('ad-clicks').value)||0,leads:parseInt(document.getElementById('ad-leads').value)||0,
    revenue:parseFloat(document.getElementById('ad-rev').value)||0});
  saveAdPerf(ads);closeModal();toast('Added');renderVideo(document.getElementById('main'));
}

async function aiAnalyzeAds(){
  const ads=getAdPerf();if(!ads.length){toast('No data','error');return}
  toast('Analyzing campaigns...','info');
  const enriched=ads.map(a=>({...a,ctr:a.impressions?(a.clicks/a.impressions*100).toFixed(2)+'%':'N/A',cpl:a.leads?'$'+(a.spend/a.leads).toFixed(2):'N/A',roas:a.spend?(a.revenue/a.spend).toFixed(2)+'x':'N/A'}));
  const result=await callClaude('You are an expert paid advertising strategist specializing in local service businesses (pest control and disinfection) in the Yuba-Sutter area of Northern California.',
    `Analyze this ad campaign performance data with calculated metrics and provide detailed optimization recommendations:\n\n${JSON.stringify(enriched,null,2)}\n\nProvide the following sections:\n1. PERFORMANCE SUMMARY - Overall health of the ad portfolio, best and worst performing campaigns\n2. CTR OPTIMIZATION - Which campaigns have low CTR and specific creative/targeting fixes\n3. COST PER LEAD ANALYSIS - Which campaigns are cost-efficient vs wasteful, benchmarked against pest control industry averages ($15-40 CPL)\n4. ROAS RANKINGS - Rank campaigns by ROAS, identify which to scale (ROAS>3x) and which to pause (ROAS<1x)\n5. BUDGET REALLOCATION - Specific dollar amounts to shift between campaigns\n6. CREATIVE RECOMMENDATIONS - Ad copy, imagery, and video suggestions for underperforming campaigns\n7. AUDIENCE ADJUSTMENTS - Targeting changes for each platform\n8. ACTION ITEMS - Prioritized list of 5 immediate changes to make`);
  if(result) showModal(`<h2><i class="fas fa-brain"></i> Campaign Analysis & Optimization</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// TikTok Strategy
function renderTikTokStrategy(el){
  el.innerHTML=`<div class="card">
    <div class="card-header"><span class="card-title"><i class="fab fa-tiktok"></i> TikTok Strategy Panel</span></div>
    <button class="btn btn-warn mb-16" onclick="aiTikTokStrategy()"><i class="fas fa-brain"></i> Generate TikTok Strategy</button>
    <div id="tiktok-output"></div>
  </div>`;
}

async function aiTikTokStrategy(){
  document.getElementById('tiktok-output').innerHTML='<div class="relative" style="min-height:100px"><div class="loading-overlay"><div class="spinner"></div></div></div>';
  const result=await callClaude('You are a TikTok marketing expert for local service businesses.',
    'Create a comprehensive TikTok strategy for Green Bones Pest Control and Green Clean Disinfectants in Yuba City CA.\n\nInclude:\n1. Trending content formats for pest control/cleaning\n2. Daily posting strategy\n3. Best hashtag sets\n4. TikTok Promote vs Ads Manager guidance\n5. 10 specific video ideas with hooks\n6. Best posting times for the Sacramento Valley area');
  if(result) document.getElementById('tiktok-output').innerHTML=`<div style="white-space:pre-wrap;line-height:1.7">${result}</div>`;
}

// ==================== MODULE 6: REVIEWS & REPUTATION ====================
let reviewTab='tracker';
let reviewSearchTerm='';
let reviewSortCol=null;
let reviewSortAsc=true;

function renderReviews(el){
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-star" style="color:var(--accent-light)"></i> Reviews & Reputation Manager</h1></div>
    <div class="tabs">
      <div class="tab ${reviewTab==='tracker'?'active':''}" onclick="reviewTab='tracker';renderReviews(document.getElementById('main'))">Reviews</div>
      <div class="tab ${reviewTab==='reputation'?'active':''}" onclick="reviewTab='reputation';renderReviews(document.getElementById('main'))">Reputation Dashboard</div>
    </div>
    <div id="review-content"></div>`;
  const c=document.getElementById('review-content');
  if(reviewTab==='tracker') renderReviewTracker(c);
  else renderReputationDash(c);
}

function renderReviewTracker(el){
  const allReviews=getReviews();
  const needsResponse=allReviews.filter(r=>(r.responseStatus||'Needs Response')==='Needs Response').length;
  const platforms=['Google','Yelp','Facebook','Nextdoor','BBB'];
  const platStats=platforms.map(p=>{
    const pr=allReviews.filter(r=>r.platform===p);
    return {name:p,count:pr.length,avg:pr.length?(pr.reduce((s,r)=>s+r.rating,0)/pr.length).toFixed(1):'N/A'};
  }).filter(p=>p.count>0);
  const overallAvg=allReviews.length?(allReviews.reduce((s,r)=>s+r.rating,0)/allReviews.length).toFixed(1):'N/A';

  // Filter reviews by search term
  let reviews=allReviews;
  if(reviewSearchTerm){
    const q=reviewSearchTerm.toLowerCase();
    reviews=reviews.filter(r=>(r.platform||'').toLowerCase().includes(q)||(r.customer||'').toLowerCase().includes(q)||(r.text||'').toLowerCase().includes(q)||(r.business||'').toLowerCase().includes(q)||(r.responseStatus||'').toLowerCase().includes(q));
  }
  // Sort reviews by column
  if(reviewSortCol){
    const key=reviewSortCol;
    reviews=[...reviews].sort((a,b)=>{
      let va=a[key]||'',vb=b[key]||'';
      if(key==='rating'){va=Number(va)||0;vb=Number(vb)||0;}
      if(typeof va==='number') return reviewSortAsc?va-vb:vb-va;
      return reviewSortAsc?String(va).localeCompare(String(vb)):String(vb).localeCompare(String(va));
    });
  }

  const sortIcon=(col)=>reviewSortCol===col?(reviewSortAsc?' <i class="fas fa-sort-up"></i>':' <i class="fas fa-sort-down"></i>'):' <i class="fas fa-sort" style="opacity:.3"></i>';

  el.innerHTML=`
    <div class="grid grid-4 mb-16">
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-star"></i></div><div class="kpi-value">${overallAvg}</div><div class="kpi-label">Overall Avg Rating</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-comments"></i></div><div class="kpi-value">${allReviews.length}</div><div class="kpi-label">Total Reviews</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-exclamation-circle"></i></div><div class="kpi-value" style="color:${needsResponse>0?'var(--warn)':'var(--success)'}">${needsResponse}</div><div class="kpi-label">Needs Response</div></div>
      ${platStats.map(p=>`<div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-chart-bar"></i></div><div class="kpi-value">${p.avg}</div><div class="kpi-label">${p.name} (${p.count})</div></div>`).join('')}
    </div>
    <div class="toolbar">
      <button class="btn btn-primary" onclick="showAddReviewModal()"><i class="fas fa-plus"></i> Add Review</button>
      <button class="btn btn-ghost" onclick="aiReviewRequestTemplates()"><i class="fas fa-envelope"></i> Review Request Templates</button>
      <input style="max-width:250px" placeholder="Search reviews..." value="${reviewSearchTerm}" oninput="reviewSearchTerm=this.value;renderReviewTracker(document.getElementById('review-content'))">
    </div>
    <div class="card overflow-auto">
      <table><thead><tr>
        <th style="cursor:pointer" onclick="toggleReviewSort('platform')">Platform${sortIcon('platform')}</th>
        <th style="cursor:pointer" onclick="toggleReviewSort('rating')">Rating${sortIcon('rating')}</th>
        <th style="cursor:pointer" onclick="toggleReviewSort('date')">Date${sortIcon('date')}</th>
        <th style="cursor:pointer" onclick="toggleReviewSort('customer')">Customer${sortIcon('customer')}</th>
        <th>Review</th>
        <th style="cursor:pointer" onclick="toggleReviewSort('business')">Business${sortIcon('business')}</th>
        <th style="cursor:pointer" onclick="toggleReviewSort('responseStatus')">Status${sortIcon('responseStatus')}</th>
        <th>Actions</th>
      </tr></thead>
      <tbody>${reviews.map(r=>`<tr>
        <td>${r.platform}</td>
        <td>${'&#9733;'.repeat(r.rating)}${'&#9734;'.repeat(5-r.rating)}</td>
        <td>${formatDate(r.date)}</td><td>${r.customer||'-'}</td>
        <td class="text-sm" style="max-width:300px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${r.text||'-'}</td>
        <td class="text-xs">${r.business&&r.business.includes('Bones')?'GB':'GC'}</td>
        <td>${statusBadge(r.responseStatus||'Needs Response')}</td>
        <td>
          <button class="btn-icon" title="Generate Response" onclick="aiReviewResponse(${r.id})"><i class="fas fa-reply"></i></button>
          <button class="btn-icon" onclick="deleteReview(${r.id})"><i class="fas fa-trash"></i></button>
        </td></tr>`).join('')||'<tr><td colspan="8" class="text-muted">No reviews tracked</td></tr>'}</tbody></table>
    </div>`;
}

function toggleReviewSort(col){
  if(reviewSortCol===col) reviewSortAsc=!reviewSortAsc;
  else{reviewSortCol=col;reviewSortAsc=true;}
  renderReviewTracker(document.getElementById('review-content'));
}

function showAddReviewModal(){
  showModal(`<h2><i class="fas fa-star"></i> Add Review</h2>
    <div class="form-row">
      <div class="form-group"><label>Platform</label><select id="rv-plat"><option>Google</option><option>Yelp</option><option>Facebook</option><option>Nextdoor</option><option>BBB</option></select></div>
      <div class="form-group"><label>Business</label><select id="rv-biz"><option>Green Bones Pest Control</option><option>Green Clean Disinfectants</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Rating</label><select id="rv-rate"><option>5</option><option>4</option><option>3</option><option>2</option><option>1</option></select></div>
      <div class="form-group"><label>Customer Name</label><input id="rv-cust"></div>
    </div>
    <div class="form-group"><label>Review Text</label><textarea id="rv-text" rows="3"></textarea></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addReview()">Add</button></div>`);
}

function addReview(){
  const reviews=getReviews();
  reviews.push({id:nextId(reviews),platform:document.getElementById('rv-plat').value,business:document.getElementById('rv-biz').value,
    rating:parseInt(document.getElementById('rv-rate').value),customer:document.getElementById('rv-cust').value,
    text:document.getElementById('rv-text').value,date:new Date().toISOString().slice(0,10),responseStatus:'Needs Response'});
  saveReviews(reviews);closeModal();toast('Review added');renderReviews(document.getElementById('main'));
}

function deleteReview(id){
  if(!confirm('Delete?'))return;
  saveReviews(getReviews().filter(r=>r.id!==id));toast('Deleted');renderReviews(document.getElementById('main'));
}

async function aiReviewResponse(id){
  const r=getReviews().find(x=>x.id===id);if(!r)return;
  toast('Generating response...','info');
  const type=r.rating>=4?'positive':'negative';
  const result=await callClaude(
    `You write professional, personalized review responses for ${r.business} in Yuba City CA.`,
    `Write a ${type} review response:\nPlatform: ${r.platform}\nRating: ${r.rating}/5\nCustomer: ${r.customer}\nReview: ${r.text}\n\nFor positive: be grateful, mention their specific service, encourage referrals.\nFor negative: be empathetic, address the concern, offer resolution, take it offline.\nKeep the brand voice warm and professional.`
  );
  if(result){
    showModal(`<h2><i class="fas fa-reply"></i> Review Response</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div>
      <div class="form-actions">
        <button class="btn btn-secondary" onclick="closeModal()">Close</button>
        <button class="btn btn-primary" onclick="navigator.clipboard.writeText('${result.replace(/'/g,"\\'")}');markResponded(${id});toast('Copied!')"><i class="fas fa-copy"></i> Copy & Mark Responded</button>
      </div>`);
  }
}

function markResponded(id){
  const reviews=getReviews();const idx=reviews.findIndex(x=>x.id===id);
  if(idx>=0){reviews[idx].responseStatus='Responded';saveReviews(reviews)}
}

async function aiReviewRequestTemplates(){
  toast('Generating review request templates...','info');
  const result=await callClaude('You help local businesses ask for reviews naturally. Return structured output with clear section headers.',
    `Generate review request templates for Green Bones Pest Control and Green Clean Disinfectants in Yuba City CA:\n\n1. TEXT MESSAGE (must be under 160 characters, include [GOOGLE_REVIEW_LINK] placeholder)\n2. EMAIL VERSION (short, personal, direct link placeholder [GOOGLE_REVIEW_LINK], professional signature)\n3. VERBAL SCRIPT (natural after-service script the tech can say in person)\n\nMake them feel genuine, not pushy. Each template should mention the specific business name.`);
  if(result){
    const escaped=result.replace(/\\/g,'\\\\').replace(/'/g,"\\'").replace(/\n/g,'\\n');
    showModal(`<h2><i class="fas fa-envelope"></i> Review Request Templates</h2>
      <div style="white-space:pre-wrap;line-height:1.7">${result}</div>
      <div class="form-actions">
        <button class="btn btn-secondary" onclick="closeModal()">Close</button>
        <button class="btn btn-primary" onclick="navigator.clipboard.writeText('${escaped}');toast('All templates copied!')"><i class="fas fa-copy"></i> Copy All</button>
      </div>`,'modal-lg');
  }
}

function renderReputationDash(el){
  const reviews=getReviews();
  const platforms=['Google','Yelp','Facebook','Nextdoor','BBB'];
  const businesses=['Green Bones Pest Control','Green Clean Disinfectants'];
  el.innerHTML=`<div class="grid grid-2">
    ${businesses.map(biz=>{
      const bizReviews=reviews.filter(r=>r.business===biz);
      const totalAvg=bizReviews.length?(bizReviews.reduce((s,r)=>s+r.rating,0)/bizReviews.length).toFixed(1):'N/A';
      const responseRate=bizReviews.length?Math.round(bizReviews.filter(r=>r.responseStatus==='Responded').length/bizReviews.length*100):0;
      return `<div class="card">
        <div class="card-header"><span class="card-title">${biz}</span></div>
        <div style="text-align:center;padding:16px 0;border-bottom:1px solid var(--border)">
          <div style="font-size:48px;font-weight:700;color:var(--accent-light)">${totalAvg}</div>
          <div class="text-muted">Overall Rating</div>
          <div style="font-size:24px;color:var(--warn);margin-top:4px">${'&#9733;'.repeat(Math.round(totalAvg)||0)}${'&#9734;'.repeat(5-(Math.round(totalAvg)||0))}</div>
          <div class="mt-8"><span style="font-size:20px;font-weight:600;color:${responseRate>=80?'var(--success)':responseRate>=50?'var(--warn)':'var(--danger)'}">${responseRate}%</span> <span class="text-muted">Response Rate</span></div>
        </div>
        ${platforms.map(p=>{
          const pReviews=bizReviews.filter(r=>r.platform===p);
          const avg=pReviews.length?(pReviews.reduce((s,r)=>s+r.rating,0)/pReviews.length).toFixed(1):'N/A';
          return `<div class="flex-between" style="padding:8px 0;border-bottom:1px solid var(--border)">
            <span>${p}</span>
            <span>${avg} ${'&#9733;'.repeat(Math.round(avg)||0)} (${pReviews.length} reviews)</span>
          </div>`}).join('')}
      </div>`}).join('')}
  </div>
  <div class="card mt-16">
    <div class="card-header"><span class="card-title">Rating Trend Over Time</span></div>
    <canvas id="chart-review-trend" height="200"></canvas>
  </div>
  <div class="card mt-16">
    <div class="card-header"><span class="card-title">Review Volume Over Time</span></div>
    <canvas id="chart-reviews" height="200"></canvas>
  </div>
  <div style="margin-top:16px;text-align:center">
    <button class="btn btn-warn" onclick="aiSentimentAnalysis()"><i class="fas fa-brain"></i> Sentiment Analysis (Last 20 Reviews)</button>
  </div>`;
  if(reviews.length){
    const months=[...new Set(reviews.map(r=>r.date?.slice(0,7)))].sort();
    const gbData=months.map(m=>reviews.filter(r=>r.date?.startsWith(m)&&r.business?.includes('Bones')).length);
    const gcData=months.map(m=>reviews.filter(r=>r.date?.startsWith(m)&&r.business?.includes('Clean')).length);
    createChart('chart-reviews',{type:'line',data:{labels:months,datasets:[
      {label:'Green Bones',data:gbData,borderColor:'#2D6A2D',fill:false,tension:.3},
      {label:'Green Clean',data:gcData,borderColor:'#3b82f6',fill:false,tension:.3}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Review Volume',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}}}}});
    // Rating trend line chart
    const gbAvgByMonth=months.map(m=>{const mr=reviews.filter(r=>r.date?.startsWith(m)&&r.business?.includes('Bones'));return mr.length?(mr.reduce((s,r)=>s+r.rating,0)/mr.length):null;});
    const gcAvgByMonth=months.map(m=>{const mr=reviews.filter(r=>r.date?.startsWith(m)&&r.business?.includes('Clean'));return mr.length?(mr.reduce((s,r)=>s+r.rating,0)/mr.length):null;});
    createChart('chart-review-trend',{type:'line',data:{labels:months,datasets:[
      {label:'Green Bones Avg Rating',data:gbAvgByMonth,borderColor:'#2D6A2D',fill:false,tension:.3,spanGaps:true},
      {label:'Green Clean Avg Rating',data:gcAvgByMonth,borderColor:'#3b82f6',fill:false,tension:.3,spanGaps:true}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{min:1,max:5,ticks:{color:'#9CA3AF',stepSize:1},grid:{color:'#2A2D37'}}}}});
  }
}

async function aiSentimentAnalysis(){
  const reviews=getReviews();
  const last20=reviews.slice(-20);
  if(!last20.length){toast('No reviews to analyze','info');return;}
  toast('Analyzing sentiment...','info');
  const reviewData=last20.map(r=>`[${r.platform}] ${r.rating}/5 - ${r.business} - "${r.text}" (${r.customer||'Anonymous'})`).join('\n');
  const result=await callClaude('You are a reputation management analyst for local service businesses.',
    `Analyze the sentiment of these recent reviews for Green Bones Pest Control and Green Clean Disinfectants:\n\n${reviewData}\n\nProvide:\n1. Overall sentiment summary (positive/negative/mixed)\n2. Common themes in positive reviews\n3. Common complaints or concerns\n4. Specific customer pain points to address\n5. Recommended response priorities\n6. Actionable reputation improvement suggestions`);
  if(result) showModal(`<h2><i class="fas fa-brain"></i> Sentiment Analysis</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// ==================== MODULE 7: COMPETITOR INTELLIGENCE ====================
let compSearchTerm='';

function renderCompetitors(el){
  const allComps=getCompetitors();
  let comps=allComps;
  if(compSearchTerm){
    const q=compSearchTerm.toLowerCase();
    comps=comps.filter(c=>(c.name||'').toLowerCase().includes(q)||(c.services||'').toLowerCase().includes(q)||(c.pricing||'').toLowerCase().includes(q)||(c.strengths||'').toLowerCase().includes(q)||(c.weaknesses||'').toLowerCase().includes(q));
  }
  el.innerHTML=`
    <div class="module-header flex-between">
      <div><h1><i class="fas fa-chess" style="color:var(--accent-light)"></i> Competitor Intelligence</h1></div>
      <div class="flex gap-8">
        <button class="btn btn-primary" onclick="showAddCompetitorModal()"><i class="fas fa-plus"></i> Add Competitor</button>
        <button class="btn btn-warn" onclick="aiFindAdvantages()"><i class="fas fa-brain"></i> Find My Advantages</button>
        <button class="btn btn-ghost" onclick="aiPricingStrategy()"><i class="fas fa-dollar-sign"></i> Pricing Strategy</button>
      </div>
    </div>
    <div class="toolbar mb-16">
      <input style="max-width:300px" placeholder="Search competitors..." value="${compSearchTerm}" oninput="compSearchTerm=this.value;renderCompetitors(document.getElementById('main'))">
      <span class="text-muted text-sm">${comps.length} competitor${comps.length!==1?'s':''}</span>
    </div>
    <div class="card overflow-auto mb-16">
      <table><thead><tr>
        <th>Name</th><th>Services</th><th>Pricing</th><th>Google Rating</th><th>Reviews</th><th>Strengths</th><th>Weaknesses</th><th>Actions</th>
      </tr></thead>
      <tbody>${comps.map(c=>`<tr>
        <td style="font-weight:600">${c.name}</td>
        <td class="text-sm">${c.services||'-'}</td>
        <td class="text-sm">${c.pricing||'-'}</td>
        <td>${c.googleRating?c.googleRating+' '+'&#9733;'.repeat(Math.round(c.googleRating)):'-'}</td>
        <td>${c.reviewCount||0}</td>
        <td class="text-sm" style="max-width:200px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${c.strengths||'-'}</td>
        <td class="text-sm" style="max-width:200px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${c.weaknesses||'-'}</td>
        <td style="white-space:nowrap">
          <button class="btn-icon" title="SWOT Analysis" onclick="aiAnalyzeCompetitor(${c.id})"><i class="fas fa-brain"></i></button>
          <button class="btn-icon" title="Delete" onclick="deleteCompetitor(${c.id})"><i class="fas fa-trash"></i></button>
        </td></tr>`).join('')||'<tr><td colspan="8" class="text-muted">No competitors tracked yet</td></tr>'}</tbody></table>
    </div>
    <div class="grid grid-2">
      ${comps.map(c=>`<div class="card">
        <div class="card-header"><span class="card-title">${c.name}</span>
          <div class="flex gap-8">
            <button class="btn btn-sm btn-warn" onclick="aiAnalyzeCompetitor(${c.id})"><i class="fas fa-brain"></i> SWOT</button>
            <button class="btn-icon" onclick="deleteCompetitor(${c.id})"><i class="fas fa-trash"></i></button>
          </div>
        </div>
        <div class="text-sm">
          <div class="flex-between mb-8"><span class="text-muted">Services:</span><span>${c.services||'-'}</span></div>
          <div class="flex-between mb-8"><span class="text-muted">Pricing:</span><span>${c.pricing||'-'}</span></div>
          <div class="flex-between mb-8"><span class="text-muted">Google Rating:</span><span>${c.googleRating||'-'} ${'&#9733;'.repeat(Math.round(c.googleRating)||0)} (${c.reviewCount||0} reviews)</span></div>
          <div class="flex-between mb-8"><span class="text-muted">Strengths:</span><span>${c.strengths||'-'}</span></div>
          <div class="flex-between"><span class="text-muted">Weaknesses:</span><span>${c.weaknesses||'-'}</span></div>
        </div>
      </div>`).join('')}
    </div>`;
}

function showAddCompetitorModal(){
  showModal(`<h2><i class="fas fa-chess"></i> Add Competitor</h2>
    <div class="form-row">
      <div class="form-group"><label>Name</label><input id="comp-name"></div>
      <div class="form-group"><label>Website</label><input id="comp-web"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Services</label><input id="comp-svc" placeholder="Comma-separated"></div>
      <div class="form-group"><label>Estimated Pricing</label><input id="comp-price"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Google Rating</label><input id="comp-rate" type="number" step="0.1" max="5"></div>
      <div class="form-group"><label># of Reviews</label><input id="comp-revcount" type="number"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Strengths</label><input id="comp-str"></div>
      <div class="form-group"><label>Weaknesses</label><input id="comp-weak"></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addCompetitor()">Add</button></div>`);
}

function addCompetitor(){
  const comps=getCompetitors();
  comps.push({id:nextId(comps),name:document.getElementById('comp-name').value,website:document.getElementById('comp-web').value,
    services:document.getElementById('comp-svc').value,pricing:document.getElementById('comp-price').value,
    googleRating:parseFloat(document.getElementById('comp-rate').value)||0,reviewCount:parseInt(document.getElementById('comp-revcount').value)||0,
    strengths:document.getElementById('comp-str').value,weaknesses:document.getElementById('comp-weak').value});
  saveCompetitors(comps);closeModal();toast('Competitor added');renderCompetitors(document.getElementById('main'));
}

function deleteCompetitor(id){
  if(!confirm('Delete?'))return;
  saveCompetitors(getCompetitors().filter(c=>c.id!==id));toast('Deleted');renderCompetitors(document.getElementById('main'));
}

async function aiAnalyzeCompetitor(id){
  const c=getCompetitors().find(x=>x.id===id);if(!c)return;
  toast('Analyzing competitor...','info');
  const result=await callClaude('You are a competitive intelligence analyst for local pest control and disinfection businesses.',
    `SWOT analysis for competitor vs Green Bones Pest Control and Green Clean Disinfectants:\n\nCompetitor: ${c.name}\nServices: ${c.services}\nPricing: ${c.pricing}\nRating: ${c.googleRating} (${c.reviewCount} reviews)\nStrengths: ${c.strengths}\nWeaknesses: ${c.weaknesses}\n\nProvide SWOT analysis and specific differentiation strategies.`);
  if(result) showModal(`<h2>Competitor Analysis: ${c.name}</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

async function aiFindAdvantages(){
  const comps=getCompetitors();
  if(!comps.length){toast('Add competitors first','info');return;}
  toast('Finding advantages...','info');
  const result=await callClaude('You are a competitive strategy expert for local service businesses.',
    `Analyze ALL competitors vs my businesses and provide a comprehensive strategic report:\n\nMy businesses: Green Bones Pest Control & Green Clean Disinfectants (Yuba City CA)\n\nCompetitors:\n${comps.map(c=>`- ${c.name}: Services: ${c.services||'unknown'}, Pricing: ${c.pricing||'unknown'}, Rating: ${c.googleRating||'N/A'} (${c.reviewCount||0} reviews), Strengths: ${c.strengths||'unknown'}, Weaknesses: ${c.weaknesses||'unknown'}`).join('\n')}\n\nProvide:\n1. CLEAR ADVANTAGES - What we do better than every competitor\n2. VULNERABILITIES - Where competitors could beat us\n3. SERVICES TO CONSIDER - Gaps in the market we could fill\n4. POSITIONING STRATEGY - How to differentiate in marketing and messaging\n5. QUICK WINS - Immediate actions to gain competitive edge`);
  if(result) showModal(`<h2><i class="fas fa-brain"></i> Competitive Advantages</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

async function aiPricingStrategy(){
  const comps=getCompetitors();
  if(!comps.length){toast('Add competitors first','info');return;}
  toast('Analyzing pricing...','info');
  const pricingData=comps.map(c=>`- ${c.name}: Pricing: ${c.pricing||'unknown'}, Rating: ${c.googleRating||'N/A'} (${c.reviewCount||0} reviews), Services: ${c.services||'unknown'}`).join('\n');
  const result=await callClaude('You are a pricing strategy consultant for local service businesses.',
    `Analyze competitor pricing and recommend optimal pricing strategy for Green Bones Pest Control & Green Clean Disinfectants (Yuba City CA):\n\nCompetitor pricing data:\n${pricingData}\n\nProvide:\n1. MARKET PRICING OVERVIEW - Price ranges and where competitors sit\n2. OPTIMAL PRICE POSITIONING - Where we should price and why\n3. VALUE-BASED PRICING OPPORTUNITIES - Premium services we can charge more for\n4. BUNDLE STRATEGIES - Service packages that maximize revenue\n5. PROMOTIONAL PRICING - Strategic discounts that win business without racing to the bottom\n6. PRICING COMMUNICATION - How to justify our pricing to customers`);
  if(result) showModal(`<h2><i class="fas fa-dollar-sign"></i> Pricing Strategy</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button></div>`,'modal-lg');
}

// ==================== MODULE 8: SEASONAL CAMPAIGN PLANNER ====================
function renderSeasonal(el){
  const months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
  const currentMonth=new Date().getMonth();

  // GB Pest data: each pest has intensity per month (0=none, 0.2=low, 0.5=medium, 0.8=high, 1.0=peak)
  const gbPests=[
    {name:'Rodents',       data:[0.8,0.8, 0.2,0.2, 0,0, 0,0, 0.5,0.5, 1.0,1.0]},
    {name:'Overwintering',  data:[0.5,0.5, 0,0, 0,0, 0,0, 0.5,0.5, 0.8,0.8]},
    {name:'Ants',           data:[0,0, 0.5,0.5, 1.0,1.0, 0.5,0.5, 0.2,0.2, 0,0]},
    {name:'Spiders',        data:[0,0, 0.5,0.5, 0.2,0.2, 1.0,1.0, 0.5,0.5, 0,0]},
    {name:'Termite Swarms', data:[0,0, 0.5,0.5, 0.2,0.2, 0,0, 0,0, 0,0]},
    {name:'Mosquitoes',     data:[0,0, 0,0, 0.5,0.5, 1.0,1.0, 0.2,0.2, 0,0]},
    {name:'Wasps',          data:[0,0, 0,0, 0.5,0.5, 1.0,1.0, 0.2,0.2, 0,0]},
    {name:'Ticks',          data:[0,0, 0.2,0.2, 0.8,0.8, 0.5,0.5, 0.2,0.2, 0,0]},
    {name:'Bed Bugs',       data:[0.2,0.2, 0.2,0.2, 0.5,0.5, 0.8,0.8, 0.5,0.5, 0.2,0.2]},
    {name:'Wildlife Excl.', data:[0,0, 0,0, 0,0, 0,0, 0.2,0.2, 0.8,0.8]}
  ];

  // GC Seasonal data
  const gcSeasons=[
    {name:'Deep Clean',         data:[0.8,0.5, 0.2,0.2, 0.2,0.2, 0.2,0.2, 0.5,0.5, 0.8,0.8]},
    {name:'Move-in Prep',       data:[0.8,0.8, 0.5,0.5, 0.8,0.8, 0.5,0.5, 0.2,0.2, 0.2,0.2]},
    {name:'Spring Cleaning',    data:[0,0, 1.0,1.0, 0.5,0.5, 0,0, 0,0, 0,0]},
    {name:'Allergy Season',     data:[0,0, 0.8,0.8, 0.5,0.5, 0,0, 0,0, 0,0]},
    {name:'Summer Prep',        data:[0,0, 0,0, 0.8,0.8, 0.5,0.5, 0,0, 0,0]},
    {name:'Kitchen Deep Clean', data:[0,0, 0.2,0.2, 0.8,0.8, 0.5,0.5, 0.5,0.5, 0.2,0.2]},
    {name:'Back-to-School',     data:[0,0, 0,0, 0,0, 0.8,1.0, 0.2,0, 0,0]},
    {name:'Daycare Disinfect',  data:[0.2,0.2, 0.2,0.2, 0.5,0.5, 0.8,0.8, 0.5,0.5, 0.2,0.2]},
    {name:'Flu Season',         data:[0.2,0.2, 0,0, 0,0, 0,0, 0.5,0.8, 1.0,1.0]},
    {name:'Holiday Prep',       data:[0,0, 0,0, 0,0, 0,0, 0.5,0.8, 1.0,0.8]}
  ];

  const campaignKey=`campaign_month_${currentMonth}`;
  const hasCampaign=DB.get(campaignKey,null);

  function buildHeatMap(pests, color){
    const labelW='110px';
    const cols=`${labelW} repeat(12,1fr)`;
    let html=`<div style="display:grid;grid-template-columns:${cols};gap:2px;font-size:11px;margin-bottom:16px">`;
    // header row
    html+=`<div style="font-weight:600;padding:4px;color:var(--text-muted)"></div>`;
    months.forEach((m,i)=>{
      const bg=i===currentMonth?'rgba(255,255,255,0.08)':'';
      const border=i===currentMonth?'border-bottom:2px solid var(--accent-light)':'';
      html+=`<div style="text-align:center;padding:4px;font-weight:600;color:var(--text-muted);${bg};${border}">${m}</div>`;
    });
    // data rows
    pests.forEach(pest=>{
      html+=`<div style="padding:4px 6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-weight:500" title="${pest.name}">${pest.name}</div>`;
      pest.data.forEach((intensity,i)=>{
        const bg=intensity>0?`background:${color};opacity:1`:'';
        const cellBg=i===currentMonth?'background:rgba(255,255,255,0.04)':'';
        const label=intensity>=1?'PEAK':intensity>=0.8?'High':intensity>=0.5?'Med':intensity>=0.2?'Low':'';
        html+=`<div style="position:relative;padding:4px;text-align:center;border-radius:3px;${cellBg}">`;
        if(intensity>0){
          html+=`<div style="position:absolute;inset:1px;border-radius:3px;background:${color};opacity:${intensity}"></div>`;
          html+=`<span style="position:relative;font-size:10px;font-weight:600;color:#fff;text-shadow:0 1px 2px rgba(0,0,0,.5)">${label}</span>`;
        }
        html+=`</div>`;
      });
    });
    html+=`</div>`;
    return html;
  }

  const alertBanner=!hasCampaign?`
    <div style="background:rgba(239,68,68,.12);border:1px solid rgba(239,68,68,.3);border-radius:var(--radius);padding:12px 16px;margin-bottom:16px;display:flex;align-items:center;gap:10px">
      <i class="fas fa-triangle-exclamation" style="color:var(--danger);font-size:16px"></i>
      <span style="color:var(--danger);font-weight:500">${months[currentMonth]} campaign has not been generated yet! Select the month and generate a plan below.</span>
    </div>`:'';

  const monthOptions=months.map((m,i)=>`<option value="${i}"${i===currentMonth?' selected':''}>${m}</option>`).join('');

  el.innerHTML=`
    <div class="module-header flex-between">
      <div><h1><i class="fas fa-calendar-days" style="color:var(--accent-light)"></i> Seasonal Campaign Planner</h1></div>
    </div>
    ${alertBanner}
    <div class="section-title"><i class="fas fa-bug"></i> Green Bones Pest Calendar (12-Month Heat Map)</div>
    <div class="card" style="overflow-x:auto">
      ${buildHeatMap(gbPests,'#2D6A2D')}
    </div>
    <div class="section-title" style="margin-top:20px"><i class="fas fa-spray-can-sparkles"></i> Green Clean Seasonal Calendar (12-Month Heat Map)</div>
    <div class="card" style="overflow-x:auto">
      ${buildHeatMap(gcSeasons,'#3b82f6')}
    </div>
    <div class="card" style="margin-top:20px">
      <div class="card-header"><span class="card-title"><i class="fas fa-bullhorn"></i> Monthly Campaign Generator</span></div>
      <div style="padding:16px;display:flex;align-items:center;gap:12px;flex-wrap:wrap">
        <label style="font-weight:500">Select Month:</label>
        <select id="seasonalMonthSelect" style="padding:6px 12px;border-radius:var(--radius);background:var(--card);color:var(--text);border:1px solid rgba(255,255,255,.1);font-size:14px">
          ${monthOptions}
        </select>
        <button class="btn btn-primary" onclick="aiMonthlyCampaign()"><i class="fas fa-brain"></i> Generate Campaign Plan</button>
        ${hasCampaign?`<span class="season-tag" style="background:rgba(45,106,45,.25);color:var(--accent-light)"><i class="fas fa-check"></i> ${months[currentMonth]} plan generated</span>`:''}
      </div>
      <p class="text-muted" style="padding:0 16px 16px">Generates a complete monthly marketing campaign plan for both Green Bones and Green Clean using AI.</p>
    </div>`;
}

async function aiMonthlyCampaign(){
  const months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
  const selEl=document.getElementById('seasonalMonthSelect');
  const monthIdx=selEl?parseInt(selEl.value):new Date().getMonth();
  const monthName=new Date(2026,monthIdx).toLocaleString('en-US',{month:'long'});
  toast(`Generating ${monthName} campaign plan...`,'info');
  const result=await callClaude(
    'You are a marketing strategist for pest control and disinfection businesses in Northern California\'s Yuba-Sutter area.',
    `Create a complete campaign plan for ${monthName} for both:\n1. Green Bones Pest Control\n2. Green Clean Disinfectants\n\nFor each business include:\n- Key pests/services to promote this month\n- 4 social media campaign themes with post ideas\n- 2 ad campaign concepts (Google Ads + Facebook)\n- Special offer ideas tied to the season\n- 3 blog post topics with SEO keywords\n- Email/text campaign sequence (3 emails)\n- Local event or partnership opportunities in Yuba City/Marysville\n- Budget allocation recommendations\n\nMake it specific to the Yuba City/Marysville area and current season. Be detailed and actionable.`
  );
  if(result){
    DB.set(`campaign_month_${monthIdx}`,{generated:new Date().toISOString(),month:monthName});
    showModal(`<h2><i class="fas fa-brain"></i> ${monthName} Campaign Plan</h2><div style="white-space:pre-wrap;line-height:1.7">${result}</div><div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Close</button><button class="btn btn-primary" onclick="navigator.clipboard.writeText(document.querySelector('.modal-body pre-wrap, .modal-body div[style*=pre-wrap]')?.textContent||'');toast('Copied to clipboard!','success')"><i class="fas fa-copy"></i> Copy</button></div>`,'modal-xl');
    // Re-render to clear the alert banner
    const seasonalEl=document.querySelector('[data-module="seasonal"]')||document.getElementById('seasonal-content');
    if(seasonalEl) renderSeasonal(seasonalEl);
  }
}

// ==================== MODULE 9: ANALYTICS & FINANCIALS ====================
let analyticsTab='overview';

// Data accessors for new analytics stores
function getMarketingSpend(){ return DB.get('marketingSpend',[]) }
function saveMarketingSpend(d){ DB.set('marketingSpend',d) }
function getFunnel(){ return DB.get('funnel',{websiteVisits:0,leads:0,estimates:0,jobsWon:0,repeatCustomers:0}) }
function saveFunnel(f){ DB.set('funnel',f) }
function getRevenueByService(){ return DB.get('revenueByService',[]) }
function saveRevenueByService(d){ DB.set('revenueByService',d) }

function renderAnalytics(el){
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-chart-line" style="color:var(--accent-light)"></i> Business Analytics & Financials</h1></div>
    <div class="tabs">
      <div class="tab ${analyticsTab==='overview'?'active':''}" onclick="analyticsTab='overview';renderAnalytics(document.getElementById('main'))">Overview</div>
      <div class="tab ${analyticsTab==='revenue'?'active':''}" onclick="analyticsTab='revenue';renderAnalytics(document.getElementById('main'))">Revenue</div>
      <div class="tab ${analyticsTab==='services'?'active':''}" onclick="analyticsTab='services';renderAnalytics(document.getElementById('main'))">Services</div>
      <div class="tab ${analyticsTab==='funnel'?'active':''}" onclick="analyticsTab='funnel';renderAnalytics(document.getElementById('main'))">Funnel</div>
      <div class="tab ${analyticsTab==='marketing'?'active':''}" onclick="analyticsTab='marketing';renderAnalytics(document.getElementById('main'))">Marketing</div>
    </div>
    <div id="analytics-content"></div>`;
  const c=document.getElementById('analytics-content');
  if(analyticsTab==='overview') renderAnalyticsOverview(c);
  else if(analyticsTab==='revenue') renderRevenueTracking(c);
  else if(analyticsTab==='services') renderServiceMix(c);
  else if(analyticsTab==='funnel') renderPipelineFunnel(c);
  else if(analyticsTab==='marketing') renderMarketingTab(c);
}

// === OVERVIEW TAB: KPIs + summary charts ===
function renderAnalyticsOverview(el){
  const leads=getLeads();const rev=getRevenue();const ads=getAdPerf();const funnel=getFunnel();const mktg=getMarketingSpend();
  const wonLeads=leads.filter(l=>l.status==='Won');
  const totalRev=rev.reduce((s,r)=>s+r.amount,0);
  const totalAdSpend=ads.reduce((s,a)=>s+a.spend,0)+mktg.reduce((s,m)=>s+(m.google||0)+(m.facebook||0)+(m.tiktok||0)+(m.other||0),0);
  const totalLeads=funnel.leads||leads.length;
  const cac=wonLeads.length?Math.round(totalAdSpend/wonLeads.length):0;
  const avgJobValue=wonLeads.length?Math.round(totalRev/wonLeads.length):0;
  const marketingROI=totalAdSpend?((totalRev-totalAdSpend)/totalAdSpend*100).toFixed(0):0;
  const revPerLead=totalLeads?Math.round(totalRev/totalLeads):0;

  el.innerHTML=`
    <div class="grid grid-4 mb-16">
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-receipt"></i></div><div class="kpi-value">$${avgJobValue.toLocaleString()}</div><div class="kpi-label">Avg Job Value</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-dollar-sign"></i></div><div class="kpi-value">$${cac.toLocaleString()}</div><div class="kpi-label">Customer Acquisition Cost</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-chart-pie"></i></div><div class="kpi-value">${marketingROI}%</div><div class="kpi-label">Marketing ROI</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-user-tag"></i></div><div class="kpi-value">$${revPerLead.toLocaleString()}</div><div class="kpi-label">Revenue per Lead</div></div>
    </div>
    <div class="grid grid-2 mb-16">
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-money-bill-trend-up"></i></div><div class="kpi-value">$${totalRev.toLocaleString()}</div><div class="kpi-label">Total Revenue</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-bullhorn"></i></div><div class="kpi-value">$${totalAdSpend.toLocaleString()}</div><div class="kpi-label">Total Marketing Spend</div></div>
    </div>
    <div class="grid grid-2">
      <div class="card"><canvas id="chart-overview-line" height="250"></canvas></div>
      <div class="card"><canvas id="chart-overview-city" height="250"></canvas></div>
    </div>`;
  if(rev.length){
    const months=[...new Set(rev.map(r=>r.month))].sort();
    const gbRev=months.map(m=>rev.filter(r=>r.month===m&&r.business==='GB').reduce((s,r)=>s+r.amount,0));
    const gcRev=months.map(m=>rev.filter(r=>r.month===m&&r.business==='GC').reduce((s,r)=>s+r.amount,0));
    createChart('chart-overview-line',{type:'line',data:{labels:months,datasets:[
      {label:'Green Bones',data:gbRev,borderColor:'#2D6A2D',backgroundColor:'rgba(45,106,45,.15)',fill:true,tension:.3},
      {label:'Green Clean',data:gcRev,borderColor:'#3b82f6',backgroundColor:'rgba(59,130,246,.15)',fill:true,tension:.3}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Revenue Over Time',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'}}}}});
  }
  const cityData={};rev.forEach(r=>{if(r.city)cityData[r.city]=(cityData[r.city]||0)+r.amount});
  if(Object.keys(cityData).length){
    const sorted=Object.entries(cityData).sort((a,b)=>b[1]-a[1]);
    createChart('chart-overview-city',{type:'bar',data:{labels:sorted.map(s=>s[0]),datasets:[{label:'Revenue',data:sorted.map(s=>s[1]),backgroundColor:'rgba(45,106,45,.7)'}]},options:{responsive:true,plugins:{legend:{display:false},title:{display:true,text:'Revenue by City',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'}}}}});
  }
}

// === REVENUE TAB ===
function renderRevenueTracking(el){
  const rev=getRevenue();
  el.innerHTML=`
    <div class="toolbar"><button class="btn btn-primary" onclick="showAddRevenueModal()"><i class="fas fa-plus"></i> Add Revenue Entry</button></div>
    <div class="grid grid-2 mb-16">
      <div class="card"><canvas id="chart-rev-line" height="250"></canvas></div>
      <div class="card"><canvas id="chart-rev-stacked" height="250"></canvas></div>
    </div>
    <div class="card overflow-auto">
      <table><thead><tr><th>Month</th><th>Business</th><th>Service</th><th>City</th><th>Amount</th><th>Actions</th></tr></thead>
      <tbody>${rev.sort((a,b)=>b.month?.localeCompare(a.month)).map(r=>`<tr>
        <td>${r.month}</td><td>${r.business==='GB'?'Green Bones':'Green Clean'}</td>
        <td>${r.service||'-'}</td><td>${r.city||'-'}</td><td>$${Number(r.amount).toLocaleString()}</td>
        <td><button class="btn-icon" onclick="deleteRevenue(${r.id})"><i class="fas fa-trash"></i></button></td>
      </tr>`).join('')||'<tr><td colspan="6" class="text-muted">No revenue data</td></tr>'}</tbody></table>
    </div>`;
  if(rev.length){
    const months=[...new Set(rev.map(r=>r.month))].sort();
    const gbRev=months.map(m=>rev.filter(r=>r.month===m&&r.business==='GB').reduce((s,r)=>s+r.amount,0));
    const gcRev=months.map(m=>rev.filter(r=>r.month===m&&r.business==='GC').reduce((s,r)=>s+r.amount,0));
    createChart('chart-rev-line',{type:'line',data:{labels:months,datasets:[
      {label:'Green Bones',data:gbRev,borderColor:'#2D6A2D',backgroundColor:'rgba(45,106,45,.15)',fill:true,tension:.3},
      {label:'Green Clean',data:gcRev,borderColor:'#3b82f6',backgroundColor:'rgba(59,130,246,.15)',fill:true,tension:.3}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Revenue Trend (Line)',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{ticks:{color:'#9CA3AF',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'}}}}});
    createChart('chart-rev-stacked',{type:'bar',data:{labels:months,datasets:[
      {label:'Green Bones',data:gbRev,backgroundColor:'rgba(45,106,45,.7)'},
      {label:'Green Clean',data:gcRev,backgroundColor:'rgba(59,130,246,.7)'}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Monthly Comparison (Stacked)',color:'#9CA3AF'}},scales:{x:{stacked:true,ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{stacked:true,ticks:{color:'#9CA3AF',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'}}}}});
  }
}

function showAddRevenueModal(){
  showModal(`<h2>Add Revenue Entry</h2>
    <div class="form-row">
      <div class="form-group"><label>Month</label><input id="rev-month" type="month" value="${new Date().toISOString().slice(0,7)}"></div>
      <div class="form-group"><label>Business</label><select id="rev-biz"><option value="GB">Green Bones</option><option value="GC">Green Clean</option></select></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Service Type</label><select id="rev-svc">${[...CONFIG.gbServices,...CONFIG.gcServices].map(s=>`<option>${s}</option>`).join('')}</select></div>
      <div class="form-group"><label>City</label><input id="rev-city" type="text" placeholder="e.g. Yuba City"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Amount ($)</label><input id="rev-amt" type="number"></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addRevenue()">Add</button></div>`);
}

function addRevenue(){
  const rev=getRevenue();
  rev.push({id:nextId(rev),month:document.getElementById('rev-month').value,business:document.getElementById('rev-biz').value,
    service:document.getElementById('rev-svc').value,city:document.getElementById('rev-city').value.trim(),amount:parseFloat(document.getElementById('rev-amt').value)||0});
  saveRevenue(rev);closeModal();toast('Revenue added');renderAnalytics(document.getElementById('main'));
}

function deleteRevenue(id){
  saveRevenue(getRevenue().filter(r=>r.id!==id));toast('Deleted');renderAnalytics(document.getElementById('main'));
}

// === SERVICES TAB: pie charts per business + revenue by city ===
function renderServiceMix(el){
  const rev=getRevenue();
  el.innerHTML=`
    <div class="grid grid-2 mb-16">
      <div class="card"><div class="card-title mb-16">Green Bones - Service Mix</div><canvas id="chart-gb-mix" height="250"></canvas></div>
      <div class="card"><div class="card-title mb-16">Green Clean - Service Mix</div><canvas id="chart-gc-mix" height="250"></canvas></div>
    </div>
    <div class="card"><div class="card-title mb-16">Revenue by City</div><canvas id="chart-city-bar" height="250"></canvas></div>`;
  const colors=['#2D6A2D','#3b82f6','#F59E0B','#EF4444','#8B5CF6','#EC4899','#06B6D4','#22C55E','#F97316'];
  const gbSvc={};rev.filter(r=>r.business==='GB').forEach(r=>{if(r.service)gbSvc[r.service]=(gbSvc[r.service]||0)+r.amount});
  if(Object.keys(gbSvc).length) createChart('chart-gb-mix',{type:'pie',data:{labels:Object.keys(gbSvc),datasets:[{data:Object.values(gbSvc),backgroundColor:colors}]},options:{responsive:true,plugins:{legend:{position:'bottom',labels:{color:'#9CA3AF'}}}}});
  const gcSvc={};rev.filter(r=>r.business==='GC').forEach(r=>{if(r.service)gcSvc[r.service]=(gcSvc[r.service]||0)+r.amount});
  if(Object.keys(gcSvc).length) createChart('chart-gc-mix',{type:'pie',data:{labels:Object.keys(gcSvc),datasets:[{data:Object.values(gcSvc),backgroundColor:colors.slice().reverse()}]},options:{responsive:true,plugins:{legend:{position:'bottom',labels:{color:'#9CA3AF'}}}}});
  const cityData={};rev.forEach(r=>{if(r.city)cityData[r.city]=(cityData[r.city]||0)+r.amount});
  if(Object.keys(cityData).length){
    const sorted=Object.entries(cityData).sort((a,b)=>b[1]-a[1]);
    createChart('chart-city-bar',{type:'bar',data:{labels:sorted.map(s=>s[0]),datasets:[
      {label:'GB',data:sorted.map(s=>{const c=s[0];return rev.filter(r=>r.city===c&&r.business==='GB').reduce((t,r)=>t+r.amount,0)}),backgroundColor:'rgba(45,106,45,.7)'},
      {label:'GC',data:sorted.map(s=>{const c=s[0];return rev.filter(r=>r.city===c&&r.business==='GC').reduce((t,r)=>t+r.amount,0)}),backgroundColor:'rgba(59,130,246,.7)'}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Revenue by City',color:'#9CA3AF'}},scales:{x:{stacked:true,ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{stacked:true,ticks:{color:'#9CA3AF',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'}}}}});
  }
}

// === FUNNEL TAB: CSS visual funnel + manual entry ===
function renderPipelineFunnel(el){
  const funnel=getFunnel();
  const stages=[
    {key:'websiteVisits',label:'Website Visits',icon:'fa-globe',color:'#3b82f6'},
    {key:'leads',label:'Leads',icon:'fa-user-plus',color:'#8B5CF6'},
    {key:'estimates',label:'Estimates',icon:'fa-file-invoice',color:'#F59E0B'},
    {key:'jobsWon',label:'Jobs Won',icon:'fa-trophy',color:'#22C55E'},
    {key:'repeatCustomers',label:'Repeat Customers',icon:'fa-heart',color:'#EC4899'}
  ];
  const maxVal=Math.max(...stages.map(s=>funnel[s.key]||0),1);

  let funnelHtml=stages.map((s,i)=>{
    const val=funnel[s.key]||0;
    const widthPct=Math.max(20,Math.round((val/maxVal)*100));
    const prev=i>0?(funnel[stages[i-1].key]||0):0;
    const convRate=prev>0?((val/prev)*100).toFixed(1)+'%':'--';
    return `<div style="display:flex;align-items:center;margin-bottom:4px;">
      <div style="width:100%;display:flex;flex-direction:column;align-items:center;">
        <div style="width:${widthPct}%;background:${s.color};color:#fff;padding:14px 16px;border-radius:6px;text-align:center;font-weight:600;font-size:15px;">
          <i class="fas ${s.icon}" style="margin-right:6px"></i>${s.label}: <span style="font-size:20px">${val.toLocaleString()}</span>
        </div>
        ${i>0?`<div style="color:var(--text2);font-size:12px;margin:2px 0">${convRate} conversion</div>`:'<div style="height:14px"></div>'}
      </div>
    </div>`;
  }).join('');

  el.innerHTML=`
    <div class="grid grid-2 mb-16">
      <div class="card">
        <div class="card-title mb-16">Customer Pipeline Funnel</div>
        ${funnelHtml}
      </div>
      <div class="card">
        <div class="card-title mb-16">Update Funnel Numbers</div>
        ${stages.map(s=>`<div class="form-row" style="margin-bottom:8px">
          <div class="form-group" style="flex:1"><label><i class="fas ${s.icon}" style="color:${s.color};margin-right:4px"></i>${s.label}</label>
            <input id="funnel-${s.key}" type="number" value="${funnel[s.key]||0}" min="0">
          </div>
        </div>`).join('')}
        <div class="form-actions"><button class="btn btn-primary" onclick="saveFunnelData()"><i class="fas fa-save"></i> Save Funnel</button></div>
      </div>
    </div>
    <div class="card">
      <div class="card-title mb-16">Conversion Summary</div>
      <div class="grid grid-4">
        ${stages.slice(1).map((s,i)=>{
          const prev=funnel[stages[i].key]||0;const cur=funnel[s.key]||0;
          const rate=prev>0?((cur/prev)*100).toFixed(1):0;
          return `<div class="card kpi-card"><div class="kpi-icon" style="color:${s.color}"><i class="fas ${s.icon}"></i></div><div class="kpi-value">${rate}%</div><div class="kpi-label">${stages[i].label} &rarr; ${s.label}</div></div>`;
        }).join('')}
      </div>
    </div>`;
}

function saveFunnelData(){
  const stages=['websiteVisits','leads','estimates','jobsWon','repeatCustomers'];
  const funnel={};
  stages.forEach(k=>{funnel[k]=parseInt(document.getElementById('funnel-'+k).value)||0});
  saveFunnel(funnel);toast('Funnel updated');renderAnalytics(document.getElementById('main'));
}

// === MARKETING TAB: spend tracker + spend vs revenue chart ===
function renderMarketingTab(el){
  const mktg=getMarketingSpend();const rev=getRevenue();const funnel=getFunnel();const leads=getLeads();
  const wonLeads=leads.filter(l=>l.status==='Won');
  const totalRev=rev.reduce((s,r)=>s+r.amount,0);
  const totalMktgSpend=mktg.reduce((s,m)=>s+(m.google||0)+(m.facebook||0)+(m.tiktok||0)+(m.other||0),0);
  const totalAdSpend=totalMktgSpend+getAdPerf().reduce((s,a)=>s+a.spend,0);
  const totalLeads=funnel.leads||leads.length;
  const cac=wonLeads.length?Math.round(totalAdSpend/wonLeads.length):0;
  const roi=totalAdSpend?((totalRev-totalAdSpend)/totalAdSpend*100).toFixed(0):0;
  const revPerLead=totalLeads?Math.round(totalRev/totalLeads):0;

  el.innerHTML=`
    <div class="grid grid-4 mb-16">
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-dollar-sign"></i></div><div class="kpi-value">$${cac.toLocaleString()}</div><div class="kpi-label">Customer Acquisition Cost</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-chart-pie"></i></div><div class="kpi-value">${roi}%</div><div class="kpi-label">Marketing ROI</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-user-tag"></i></div><div class="kpi-value">$${revPerLead.toLocaleString()}</div><div class="kpi-label">Revenue per Lead</div></div>
      <div class="card kpi-card"><div class="kpi-icon"><i class="fas fa-bullhorn"></i></div><div class="kpi-value">$${totalMktgSpend.toLocaleString()}</div><div class="kpi-label">Total Marketing Spend</div></div>
    </div>
    <div class="toolbar mb-16"><button class="btn btn-primary" onclick="showAddMarketingSpendModal()"><i class="fas fa-plus"></i> Add Monthly Spend</button></div>
    <div class="grid grid-2 mb-16">
      <div class="card"><canvas id="chart-mktg-vs-rev" height="250"></canvas></div>
      <div class="card"><canvas id="chart-mktg-breakdown" height="250"></canvas></div>
    </div>
    <div class="card overflow-auto">
      <table><thead><tr><th>Month</th><th>Google Ads</th><th>Facebook Ads</th><th>TikTok Ads</th><th>Print/Other</th><th>Total</th><th>Actions</th></tr></thead>
      <tbody>${mktg.sort((a,b)=>b.month?.localeCompare(a.month)).map(m=>{
        const total=(m.google||0)+(m.facebook||0)+(m.tiktok||0)+(m.other||0);
        return `<tr><td>${m.month}</td><td>$${(m.google||0).toLocaleString()}</td><td>$${(m.facebook||0).toLocaleString()}</td><td>$${(m.tiktok||0).toLocaleString()}</td><td>$${(m.other||0).toLocaleString()}</td><td><strong>$${total.toLocaleString()}</strong></td>
          <td><button class="btn-icon" onclick="deleteMarketingSpend(${m.id})"><i class="fas fa-trash"></i></button></td></tr>`;
      }).join('')||'<tr><td colspan="7" class="text-muted">No marketing spend data</td></tr>'}</tbody></table>
    </div>`;
  const allMonths=[...new Set([...mktg.map(m=>m.month),...rev.map(r=>r.month)])].sort();
  if(allMonths.length){
    const monthlyRev=allMonths.map(m=>rev.filter(r=>r.month===m).reduce((s,r)=>s+r.amount,0));
    const monthlySpend=allMonths.map(m=>{const e=mktg.find(x=>x.month===m);return e?(e.google||0)+(e.facebook||0)+(e.tiktok||0)+(e.other||0):0});
    createChart('chart-mktg-vs-rev',{type:'bar',data:{labels:allMonths,datasets:[
      {label:'Revenue',data:monthlyRev,backgroundColor:'rgba(45,106,45,.7)',yAxisID:'y'},
      {label:'Marketing Spend',data:monthlySpend,backgroundColor:'rgba(239,68,68,.7)',yAxisID:'y1'}
    ]},options:{responsive:true,plugins:{legend:{labels:{color:'#9CA3AF'}},title:{display:true,text:'Spend vs Revenue',color:'#9CA3AF'}},scales:{x:{ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{type:'linear',position:'left',ticks:{color:'#2D6A2D',callback:v=>'$'+v.toLocaleString()},grid:{color:'#2A2D37'},title:{display:true,text:'Revenue',color:'#2D6A2D'}},y1:{type:'linear',position:'right',ticks:{color:'#EF4444',callback:v=>'$'+v.toLocaleString()},grid:{drawOnChartArea:false},title:{display:true,text:'Spend',color:'#EF4444'}}}}});
  }
  const totalGoogle=mktg.reduce((s,m)=>s+(m.google||0),0);
  const totalFb=mktg.reduce((s,m)=>s+(m.facebook||0),0);
  const totalTT=mktg.reduce((s,m)=>s+(m.tiktok||0),0);
  const totalOther=mktg.reduce((s,m)=>s+(m.other||0),0);
  if(totalGoogle+totalFb+totalTT+totalOther>0){
    createChart('chart-mktg-breakdown',{type:'doughnut',data:{labels:['Google Ads','Facebook Ads','TikTok Ads','Print/Other'],datasets:[{data:[totalGoogle,totalFb,totalTT,totalOther],backgroundColor:['#F59E0B','#3b82f6','#06B6D4','#8B5CF6']}]},options:{responsive:true,plugins:{legend:{position:'bottom',labels:{color:'#9CA3AF'}},title:{display:true,text:'Spend Breakdown',color:'#9CA3AF'}}}});
  }
}

function showAddMarketingSpendModal(){
  showModal(`<h2>Add Monthly Marketing Spend</h2>
    <div class="form-row">
      <div class="form-group"><label>Month</label><input id="mktg-month" type="month" value="${new Date().toISOString().slice(0,7)}"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>Google Ads ($)</label><input id="mktg-google" type="number" value="0"></div>
      <div class="form-group"><label>Facebook Ads ($)</label><input id="mktg-facebook" type="number" value="0"></div>
    </div>
    <div class="form-row">
      <div class="form-group"><label>TikTok Ads ($)</label><input id="mktg-tiktok" type="number" value="0"></div>
      <div class="form-group"><label>Print/Other ($)</label><input id="mktg-other" type="number" value="0"></div>
    </div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addMarketingSpend()">Add</button></div>`);
}

function addMarketingSpend(){
  const mktg=getMarketingSpend();
  mktg.push({id:nextId(mktg),month:document.getElementById('mktg-month').value,
    google:parseFloat(document.getElementById('mktg-google').value)||0,
    facebook:parseFloat(document.getElementById('mktg-facebook').value)||0,
    tiktok:parseFloat(document.getElementById('mktg-tiktok').value)||0,
    other:parseFloat(document.getElementById('mktg-other').value)||0});
  saveMarketingSpend(mktg);closeModal();toast('Marketing spend added');renderAnalytics(document.getElementById('main'));
}

function deleteMarketingSpend(id){
  saveMarketingSpend(getMarketingSpend().filter(m=>m.id!==id));toast('Deleted');renderAnalytics(document.getElementById('main'));
}

// === FINANCIAL KPIs (kept for backward compat) ===
function renderFinancialKPIs(el){
  renderAnalyticsOverview(el);
}

// ==================== MODULE 10: INFRASTRUCTURE MONITOR ====================
let infraErrorSort={col:'date',dir:'desc'};
let infraErrorSearch='';

function getOpenErrorCount(){
  return getErrors().filter(e=>(e.status||'Open')==='Open').length;
}

function renderInfra(el){
  const agents=getAgents();
  const errors=getErrors();
  const costs=getApiCosts();
  const budget=parseFloat(localStorage.getItem('apiCostBudget'))||100;

  // Monthly total calculation
  const now=new Date();
  const currentMonth=now.toISOString().slice(0,7);
  const monthCosts=costs.filter(c=>c.date&&c.date.startsWith(currentMonth));
  const monthlyTotal=monthCosts.reduce((s,c)=>s+(c.cost||0),0);
  const dayOfMonth=now.getDate();
  const daysInMonth=new Date(now.getFullYear(),now.getMonth()+1,0).getDate();
  const projectedCost=dayOfMonth>0?(monthlyTotal/dayOfMonth)*daysInMonth:0;
  const overBudget=monthlyTotal>budget;

  // Sort and filter errors
  let filteredErrors=[...errors];
  if(infraErrorSearch){
    const q=infraErrorSearch.toLowerCase();
    filteredErrors=filteredErrors.filter(e=>(e.description||'').toLowerCase().includes(q)||(e.system||'').toLowerCase().includes(q)||(e.severity||'').toLowerCase().includes(q)||(e.status||'').toLowerCase().includes(q));
  }
  filteredErrors.sort((a,b)=>{
    let va=a[infraErrorSort.col]||'',vb=b[infraErrorSort.col]||'';
    if(typeof va==='string')va=va.toLowerCase();
    if(typeof vb==='string')vb=vb.toLowerCase();
    if(va<vb)return infraErrorSort.dir==='asc'?-1:1;
    if(va>vb)return infraErrorSort.dir==='asc'?1:-1;
    return 0;
  });

  // Stacked bar chart data: costs by category over time
  const byMonthCat={};const categories=new Set();
  costs.forEach(c=>{const m=c.date?.slice(0,7);const svc=c.service||'Other';if(m){if(!byMonthCat[m])byMonthCat[m]={};if(!byMonthCat[m][svc])byMonthCat[m][svc]=0;byMonthCat[m][svc]+=c.cost;categories.add(svc)}});
  const costMonths=Object.keys(byMonthCat).sort();
  const catColors={'Claude API':'rgba(139,92,246,.8)','ElevenLabs':'rgba(59,130,246,.8)','Brave Search':'rgba(245,158,11,.8)','Yelp API':'rgba(34,197,94,.8)','Other':'rgba(156,163,175,.7)'};
  const catArr=[...categories];

  const sortIcon=(col)=>infraErrorSort.col===col?(infraErrorSort.dir==='asc'?'<i class="fas fa-sort-up"></i>':'<i class="fas fa-sort-down"></i>'):'<i class="fas fa-sort" style="opacity:.3"></i>';

  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-server" style="color:var(--accent-light)"></i> Infrastructure Monitor</h1></div>

    ${overBudget?`<div class="infra-budget-banner"><i class="fas fa-exclamation-triangle"></i><span>Budget Alert: Monthly API costs ($${monthlyTotal.toFixed(2)}) exceed the $${budget.toFixed(0)} threshold!</span><button class="btn btn-sm btn-ghost" onclick="infraSetBudget()" style="margin-left:auto;color:var(--text2)"><i class="fas fa-gear"></i> Adjust</button></div>`:''}

    <div class="section-title">Agent Status</div>
    <div class="grid grid-3 mb-16">
      <div class="card">
        <div class="card-header"><span class="card-title"><i class="fas fa-desktop"></i> Winston (HP EliteDesk)</span><span class="status-dot status-${agents.winston?.status||'offline'}"></span></div>
        <div class="text-sm"><div class="mb-8">Cron: 6am/10am/2pm/6pm/10pm</div>
        <div class="mb-8">Last Run: ${agents.winston?.lastRun||'Unknown'}</div>
        <div class="mb-8">Leads Today: ${agents.winston?.leadsToday||0}</div>
        <div>Errors: ${agents.winston?.errors||0}</div></div>
        <button class="btn btn-sm btn-ghost mt-8" onclick="editAgent('winston')"><i class="fas fa-edit"></i> Update</button>
      </div>
      <div class="card">
        <div class="card-header"><span class="card-title"><i class="fas fa-microchip"></i> Rachel (Raspberry Pi)</span><span class="status-dot status-${agents.rachel?.status||'offline'}"></span></div>
        <div class="text-sm"><div class="mb-8">Services: ${agents.rachel?.services||'-'}</div>
        <div class="mb-8">Last Restart: ${agents.rachel?.lastRestart||'Unknown'}</div>
        <div>Notes: ${agents.rachel?.notes||'-'}</div></div>
        <button class="btn btn-sm btn-ghost mt-8" onclick="editAgent('rachel')"><i class="fas fa-edit"></i> Update</button>
      </div>
      <div class="card">
        <div class="card-header"><span class="card-title"><i class="fas fa-cloud"></i> Image Agent (Oracle)</span><span class="status-dot status-${agents.imageAgent?.status||'offline'}"></span></div>
        <div class="text-sm"><div class="mb-8">Last Image: ${agents.imageAgent?.lastImage||'-'}</div>
        <div class="mb-8">Model: ${agents.imageAgent?.model||'-'}</div>
        <div>Notes: ${agents.imageAgent?.notes||'-'}</div></div>
        <button class="btn btn-sm btn-ghost mt-8" onclick="editAgent('imageAgent')"><i class="fas fa-edit"></i> Update</button>
      </div>
    </div>

    <div class="section-title">API Cost Tracker</div>
    <div class="toolbar" style="justify-content:space-between">
      <button class="btn btn-primary btn-sm" onclick="showAddCostModal()"><i class="fas fa-plus"></i> Add Cost Entry</button>
      <button class="btn btn-sm btn-ghost" onclick="infraSetBudget()"><i class="fas fa-gear"></i> Budget: $${budget.toFixed(0)}</button>
    </div>

    <div class="grid grid-3 mb-16">
      <div class="infra-monthly-total card">
        <div style="font-size:13px;color:var(--text2);margin-bottom:4px"><i class="fas fa-calendar"></i> ${currentMonth} Spend</div>
        <div class="total-value" style="${overBudget?'color:var(--danger)':''}">$${monthlyTotal.toFixed(2)}</div>
        <div class="projected">Projected month-end: $${projectedCost.toFixed(2)}</div>
        <div style="margin-top:8px;height:6px;background:var(--border);border-radius:3px;overflow:hidden"><div style="height:100%;width:${Math.min(100,(monthlyTotal/budget)*100)}%;background:${overBudget?'var(--danger)':'var(--warn)'};border-radius:3px;transition:width .3s"></div></div>
        <div style="font-size:11px;color:var(--text2);margin-top:4px">${Math.round((monthlyTotal/budget)*100)}% of $${budget.toFixed(0)} budget</div>
      </div>
      <div class="card overflow-auto" style="grid-column:span 2">
        <table><thead><tr><th>Date</th><th>Service</th><th>Cost</th></tr></thead>
        <tbody>${costs.slice(0,20).map(c=>`<tr><td>${formatDate(c.date)}</td><td>${c.service}</td><td>$${c.cost?.toFixed(2)}</td></tr>`).join('')||'<tr><td colspan="3" class="text-muted">No cost data</td></tr>'}</tbody></table>
      </div>
    </div>

    <div class="card mb-16"><canvas id="chart-api-costs-stacked" height="250"></canvas></div>

    <div class="section-title">Error & Issue Log <span style="font-size:13px;color:var(--text2);font-weight:400;margin-left:8px">(${getOpenErrorCount()} open)</span></div>
    <div class="toolbar" style="justify-content:space-between">
      <button class="btn btn-primary btn-sm" onclick="showAddErrorModal()"><i class="fas fa-plus"></i> Log Error</button>
      <input class="error-search-input" placeholder="Search errors..." value="${infraErrorSearch}" oninput="infraErrorSearch=this.value;renderInfra(document.getElementById('main'))">
    </div>
    <div class="card overflow-auto">
      <table><thead><tr>
        <th class="sort-btn" onclick="infraSortErrors('date')">Date ${sortIcon('date')}</th>
        <th class="sort-btn" onclick="infraSortErrors('system')">System ${sortIcon('system')}</th>
        <th class="sort-btn" onclick="infraSortErrors('severity')">Severity ${sortIcon('severity')}</th>
        <th>Description</th>
        <th class="sort-btn" onclick="infraSortErrors('status')">Status ${sortIcon('status')}</th>
      </tr></thead>
      <tbody>${filteredErrors.map(e=>`<tr>
        <td>${formatDate(e.date)}</td><td>${e.system}</td>
        <td><span class="badge ${e.severity==='Critical'?'badge-lost':e.severity==='Warning'?'badge-quoted':'badge-new'}">${e.severity}</span></td>
        <td>${e.description}</td>
        <td>${statusBadge(e.status||'Open')}</td>
      </tr>`).join('')||'<tr><td colspan="5" class="text-muted">No errors logged</td></tr>'}</tbody></table>
    </div>`;

  // Stacked bar cost chart by category
  if(costs.length&&costMonths.length){
    createChart('chart-api-costs-stacked',{type:'bar',data:{labels:costMonths,datasets:catArr.map(cat=>({
      label:cat,data:costMonths.map(m=>(byMonthCat[m]&&byMonthCat[m][cat])||0),backgroundColor:catColors[cat]||'rgba(156,163,175,.6)'
    }))},options:{responsive:true,plugins:{legend:{position:'bottom',labels:{color:'#9CA3AF'}},title:{display:true,text:'Monthly API Costs by Category',color:'#9CA3AF'}},scales:{x:{stacked:true,ticks:{color:'#9CA3AF'},grid:{color:'#2A2D37'}},y:{stacked:true,ticks:{color:'#9CA3AF',callback:v=>'$'+v},grid:{color:'#2A2D37'}}}}});
  }
}

function infraSortErrors(col){
  if(infraErrorSort.col===col){infraErrorSort.dir=infraErrorSort.dir==='asc'?'desc':'asc'}
  else{infraErrorSort.col=col;infraErrorSort.dir='asc'}
  renderInfra(document.getElementById('main'));
}

function infraSetBudget(){
  const current=parseFloat(localStorage.getItem('apiCostBudget'))||100;
  showModal(`<h2><i class="fas fa-gear"></i> API Cost Budget</h2>
    <div class="form-group"><label>Monthly Budget Threshold ($)</label><input id="budget-val" type="number" step="1" value="${current}"></div>
    <p class="text-muted text-sm mb-16">A warning banner will appear when monthly costs exceed this amount.</p>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="localStorage.setItem('apiCostBudget',document.getElementById('budget-val').value);closeModal();toast('Budget updated');renderInfra(document.getElementById('main'))">Save</button></div>`);
}

function editAgent(name){
  const agents=getAgents();const a=agents[name]||{};
  const fields=name==='winston'?
    `<div class="form-group"><label>Status</label><select id="ag-status"><option ${a.status==='online'?'selected':''}>online</option><option ${a.status==='offline'?'selected':''}>offline</option><option ${a.status==='warning'?'selected':''}>warning</option></select></div>
     <div class="form-group"><label>Last Run</label><input id="ag-lr" value="${a.lastRun||''}"></div>
     <div class="form-group"><label>Leads Today</label><input id="ag-lt" type="number" value="${a.leadsToday||0}"></div>
     <div class="form-group"><label>Errors</label><input id="ag-err" type="number" value="${a.errors||0}"></div>`:
    `<div class="form-group"><label>Status</label><select id="ag-status"><option ${a.status==='online'?'selected':''}>online</option><option ${a.status==='offline'?'selected':''}>offline</option><option ${a.status==='warning'?'selected':''}>warning</option></select></div>
     <div class="form-group"><label>Notes</label><textarea id="ag-notes">${a.notes||''}</textarea></div>`;
  showModal(`<h2>Update ${name}</h2>${fields}
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="saveAgent('${name}')">Save</button></div>`);
}

function saveAgent(name){
  const agents=getAgents();
  agents[name]=agents[name]||{};
  agents[name].status=document.getElementById('ag-status').value;
  if(name==='winston'){
    agents[name].lastRun=document.getElementById('ag-lr').value;
    agents[name].leadsToday=parseInt(document.getElementById('ag-lt').value)||0;
    agents[name].errors=parseInt(document.getElementById('ag-err').value)||0;
  }else{
    const notes=document.getElementById('ag-notes');
    if(notes)agents[name].notes=notes.value;
  }
  saveAgents(agents);closeModal();toast('Updated');renderInfra(document.getElementById('main'));
}

function showAddCostModal(){
  showModal(`<h2>Add API Cost</h2>
    <div class="form-row">
      <div class="form-group"><label>Date</label><input id="cost-date" type="date" value="${new Date().toISOString().slice(0,10)}"></div>
      <div class="form-group"><label>Service</label><select id="cost-svc"><option>Claude API</option><option>ElevenLabs</option><option>Brave Search</option><option>Yelp API</option><option>Other</option></select></div>
    </div>
    <div class="form-group"><label>Cost ($)</label><input id="cost-amt" type="number" step="0.01"></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addCost()">Add</button></div>`);
}

function addCost(){
  const costs=getApiCosts();
  costs.push({id:nextId(costs),date:document.getElementById('cost-date').value,
    service:document.getElementById('cost-svc').value,cost:parseFloat(document.getElementById('cost-amt').value)||0});
  saveApiCosts(costs);closeModal();toast('Added');renderInfra(document.getElementById('main'));
}

function showAddErrorModal(){
  showModal(`<h2>Log Error</h2>
    <div class="form-row">
      <div class="form-group"><label>System</label><select id="err-sys"><option>Winston</option><option>Rachel</option><option>Image Agent</option><option>Website</option><option>API</option><option>Other</option></select></div>
      <div class="form-group"><label>Severity</label><select id="err-sev"><option>Critical</option><option>Warning</option><option>Info</option></select></div>
    </div>
    <div class="form-group"><label>Description</label><textarea id="err-desc"></textarea></div>
    <div class="form-actions"><button class="btn btn-secondary" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="addError()">Add</button></div>`);
}

function addError(){
  const errors=getErrors();
  errors.push({id:nextId(errors),date:new Date().toISOString().slice(0,10),system:document.getElementById('err-sys').value,
    severity:document.getElementById('err-sev').value,description:document.getElementById('err-desc').value,status:'Open'});
  saveErrors(errors);closeModal();toast('Error logged');renderInfra(document.getElementById('main'));
}

// ==================== SETTINGS ====================
function renderSettings(el){
  const apiKey=DB.get('apiKey','')||CONFIG.apiKey;
  const keyDisplay=apiKey?apiKey.slice(0,12)+'...'+apiKey.slice(-6):'Not set';
  const isConfigured=!!apiKey;
  el.innerHTML=`
    <div class="module-header"><h1><i class="fas fa-gear" style="color:var(--accent-light)"></i> Settings</h1></div>
    <div class="card" style="max-width:600px">
      <div class="card-header"><span class="card-title">API Configuration</span></div>
      <div class="form-group">
        <label>Anthropic API Key ${isConfigured?'<span class="badge badge-won">Active</span>':'<span class="badge badge-lost">Not Set</span>'}</label>
        <input id="set-apikey" type="password" value="${DB.get('apiKey','')||CONFIG.apiKey}" placeholder="sk-ant-...">
        <div class="text-xs text-muted mt-8">Current: ${keyDisplay}</div>
      </div>
      <div class="form-group"><label>Model</label><input value="${CONFIG.model}" disabled></div>
      <button class="btn btn-primary" onclick="DB.set('apiKey',document.getElementById('set-apikey').value);CONFIG.apiKey=document.getElementById('set-apikey').value;toast('API key saved')"><i class="fas fa-save"></i> Save API Key</button>
    </div>
    <div class="card mt-16" style="max-width:600px">
      <div class="card-header"><span class="card-title">Data Management</span></div>
      <div class="flex gap-8">
        <button class="btn btn-secondary" onclick="exportData()"><i class="fas fa-download"></i> Export All Data</button>
        <button class="btn btn-secondary" onclick="document.getElementById('import-file').click()"><i class="fas fa-upload"></i> Import Data</button>
        <button class="btn btn-danger" onclick="if(confirm('This will delete ALL dashboard data. Are you sure?')){Object.keys(localStorage).filter(k=>k.startsWith('gbgc_')).forEach(k=>localStorage.removeItem(k));toast('All data cleared');location.reload()}"><i class="fas fa-trash"></i> Clear All Data</button>
      </div>
    </div>
    <div class="card mt-16" style="max-width:600px">
      <div class="card-header"><span class="card-title">Load Sample Data</span></div>
      <p class="text-muted mb-8">Populate the dashboard with demo data to explore features.</p>
      <button class="btn btn-warn" onclick="loadSampleData();toast('Sample data loaded!');navigateTo('dashboard')"><i class="fas fa-database"></i> Load Sample Data</button>
    </div>`;
}

// ==================== AI CHAT PANEL ====================
function toggleChat(){
  const panel=document.getElementById('ai-chat-panel');
  const btn=document.getElementById('ai-chat-btn');
  panel.classList.toggle('open');
}

function quickChat(msg){
  document.getElementById('chat-input').value=msg;
  sendChat();
}

function detectChatTopic(msg){
  const m=msg.toLowerCase();
  if(m.includes('lead')||m.includes('pipeline')||m.includes('crm')) return 'leads';
  if(m.includes('revenue')||m.includes('financial')||m.includes('money')||m.includes('profit')) return 'revenue';
  if(m.includes('social')||m.includes('post')||m.includes('content')||m.includes('instagram')||m.includes('facebook')) return 'social';
  if(m.includes('competitor')||m.includes('competition')) return 'competitors';
  if(m.includes('season')||m.includes('pest')||m.includes('monthly')) return 'seasonal';
  if(m.includes('seo')||m.includes('keyword')||m.includes('rank')) return 'seo';
  return 'general';
}

async function sendChat(){
  const input=document.getElementById('chat-input');
  const msg=input.value.trim();if(!msg)return;
  input.value='';
  chatHistory.push({role:'user',content:msg});
  renderChatMessages();

  const topic=detectChatTopic(msg);
  const ctx=getSmartContext(topic);
  const systemPrompt=`You are an AI business advisor for Green Bones Pest Control and Green Clean Disinfectants in Yuba City, CA (Yuba-Sutter area). You have access to real-time business data and should reference it in your responses.\n\n${ctx}\n\nProvide specific, actionable, data-driven advice. Be concise but thorough. Use numbers from the data above. Format with bullet points and headers when helpful.`;

  const messages=chatHistory.map(m=>({role:m.role==='ai'?'assistant':'user',content:m.content}));
  const recentMsgs=messages.slice(-12);

  try{
    const apiKey=CONFIG.apiKey||DB.get('apiKey','');
    if(!apiKey){toast('Set API key in Settings','error');return}
    const res=await fetch(CONFIG.apiUrl,{method:'POST',headers:{'Content-Type':'application/json','x-api-key':apiKey,'anthropic-version':'2023-06-01','anthropic-dangerous-direct-browser-access':'true'},
      body:JSON.stringify({model:CONFIG.model,max_tokens:CONFIG.maxTokens,system:systemPrompt,messages:recentMsgs})});
    const data=await res.json();
    const reply=data.content?.[0]?.text||'Sorry, I couldn\'t generate a response.';
    chatHistory.push({role:'ai',content:reply});
  }catch(e){
    chatHistory.push({role:'ai',content:'Error: '+e.message});
  }
  renderChatMessages();
}

function renderChatMessages(){
  const container=document.getElementById('chat-messages');
  container.innerHTML=chatHistory.map(m=>`<div class="chat-msg ${m.role}">${m.role==='ai'?formatAIResponse(m.content):m.content.replace(/</g,'&lt;').replace(/\n/g,'<br>')}</div>`).join('');
  container.scrollTop=container.scrollHeight;
}

function formatAIResponse(text){
  return text
    .replace(/</g,'&lt;')
    .replace(/\*\*(.*?)\*\*/g,'<strong>$1</strong>')
    .replace(/^### (.*$)/gm,'<strong style="color:var(--accent-light)">$1</strong>')
    .replace(/^## (.*$)/gm,'<strong style="color:var(--accent-light);font-size:14px">$1</strong>')
    .replace(/^- (.*$)/gm,'&bull; $1')
    .replace(/^\d+\. (.*$)/gm,'<span style="color:var(--accent-light)">$&</span>')
    .replace(/\n/g,'<br>');
}

// ==================== DATA EXPORT/IMPORT ====================
function exportData(){
  const data=DB.getAll();
  const blob=new Blob([JSON.stringify(data,null,2)],{type:'application/json'});
  downloadFile(blob,'gbgc-backup-'+new Date().toISOString().slice(0,10)+'.json','application/json');
  toast('Data exported');
}

function importData(event){
  const file=event.target.files[0];if(!file)return;
  const reader=new FileReader();
  reader.onload=function(e){
    try{
      const data=JSON.parse(e.target.result);
      DB.setAll(data);
      toast('Data imported successfully!');
      navigateTo(currentModule);
    }catch(err){toast('Invalid file','error')}
  };
  reader.readAsText(file);
  event.target.value='';
}

function downloadFile(content,filename,type){
  const blob=content instanceof Blob?content:new Blob([content],{type});
  const url=URL.createObjectURL(blob);
  const a=document.createElement('a');a.href=url;a.download=filename;
  document.body.appendChild(a);a.click();document.body.removeChild(a);
  URL.revokeObjectURL(url);
}

// ==================== LOGIN ====================
function attemptLogin(){
  const pw=document.getElementById('login-pw').value;
  if(pw===CONFIG.password){
    sessionStorage.setItem('gbgc_auth','true');
    document.getElementById('login-screen').style.display='none';
    document.getElementById('app').style.display='flex';
    document.getElementById('ai-chat-btn').style.display='flex';
    initApp();
  }else{
    document.getElementById('login-error').style.display='block';
    document.getElementById('login-pw').value='';
  }
}

document.getElementById('login-pw').addEventListener('keydown',function(e){if(e.key==='Enter')attemptLogin()});

function logout(){
  sessionStorage.removeItem('gbgc_auth');
  location.reload();
}

// ==================== SAMPLE DATA ====================
function loadSampleData(){
  const today=new Date();const td=d=>new Date(today.getTime()-d*86400000).toISOString().slice(0,10);
  const tm=m=>{const d=new Date(today);d.setMonth(d.getMonth()-m);return d.toISOString().slice(0,7)};

  // Leads
  const sampleLeads=[
    {id:1,dateAdded:td(1),business:'Green Bones Pest Control',source:'Google',name:'Sarah Johnson',phone:'530-555-0101',email:'sarah@email.com',city:'Yuba City',service:'Ants',score:8,status:'Quoted',quoteAmount:350,notes:'Large ant infestation in kitchen',followUp:td(-2)},
    {id:2,dateAdded:td(2),business:'Green Bones Pest Control',source:'Nextdoor',name:'Mike Thompson',phone:'530-555-0102',email:'mike@email.com',city:'Marysville',service:'Rodents',score:9,status:'Won',quoteAmount:600,notes:'Mice in garage and attic'},
    {id:3,dateAdded:td(3),business:'Green Clean Disinfectants',source:'Website',name:'Linda Park',phone:'530-555-0103',email:'linda@email.com',city:'Plumas Lake',service:'Commercial Disinfection',score:7,status:'Contacted',quoteAmount:1200,notes:'Office building, 5000 sqft'},
    {id:4,dateAdded:td(5),business:'Green Bones Pest Control',source:'Facebook',name:'James Wright',phone:'530-555-0104',email:'',city:'Live Oak',service:'Spiders',score:6,status:'New',quoteAmount:0,notes:'Black widows in garage'},
    {id:5,dateAdded:td(7),business:'Green Clean Disinfectants',source:'Referral',name:'Amy Chen',phone:'530-555-0105',email:'amy@email.com',city:'Yuba City',service:'Residential Disinfection',score:8,status:'Won',quoteAmount:450,notes:'Post-renovation deep clean'},
    {id:6,dateAdded:td(10),business:'Green Bones Pest Control',source:'Yelp',name:'Robert Garcia',phone:'530-555-0106',email:'robert@email.com',city:'Olivehurst',service:'Termites',score:9,status:'Estimate Scheduled',quoteAmount:0,notes:'Possible termite damage in deck'},
    {id:7,dateAdded:td(12),business:'Green Bones Pest Control',source:'Angi',name:'Karen Davis',phone:'530-555-0107',email:'karen@email.com',city:'Wheatland',service:'General Pest',score:5,status:'Won',quoteAmount:250,notes:'Quarterly pest control'},
    {id:8,dateAdded:td(14),business:'Green Clean Disinfectants',source:'Google',name:'David Wilson',phone:'530-555-0108',email:'david@email.com',city:'Gridley',service:'Mold Treatment',score:7,status:'Follow Up',quoteAmount:800,notes:'Bathroom mold issue'},
    {id:9,dateAdded:td(18),business:'Green Bones Pest Control',source:'Craigslist',name:'Nancy Brown',phone:'530-555-0109',email:'',city:'Beale AFB',service:'Mosquitoes',score:4,status:'Lost',quoteAmount:200,notes:'Yard mosquito treatment',lostReason:'Went with competitor'},
    {id:10,dateAdded:td(20),business:'Green Clean Disinfectants',source:'Facebook',name:'Tom Anderson',phone:'530-555-0110',email:'tom@email.com',city:'Marysville',service:'Move-in/Move-out',score:8,status:'Won',quoteAmount:550,notes:'Move-out cleaning for rental property'},
    {id:11,dateAdded:td(0),business:'Green Bones Pest Control',source:'TikTok',name:'Jessica Lee',phone:'530-555-0111',email:'jess@email.com',city:'Yuba City',service:'Bed Bugs',score:9,status:'New',quoteAmount:0,notes:'Urgent - bed bug problem'},
    {id:12,dateAdded:td(4),business:'Green Bones Pest Control',source:'Referral',name:'Chris Martinez',phone:'530-555-0112',email:'chris@email.com',city:'Linda',service:'Wildlife',score:6,status:'Contacted',quoteAmount:0,notes:'Raccoons in crawlspace'},
  ];
  saveLeads(sampleLeads);

  // Revenue
  const sampleRevenue=[
    {id:1,month:tm(0),business:'GB',service:'Ants',amount:2800},
    {id:2,month:tm(0),business:'GB',service:'Rodents',amount:1800},
    {id:3,month:tm(0),business:'GB',service:'General Pest',amount:3200},
    {id:4,month:tm(0),business:'GC',service:'Commercial Disinfection',amount:4500},
    {id:5,month:tm(0),business:'GC',service:'Residential Disinfection',amount:2100},
    {id:6,month:tm(1),business:'GB',service:'Ants',amount:2400},
    {id:7,month:tm(1),business:'GB',service:'Spiders',amount:1600},
    {id:8,month:tm(1),business:'GB',service:'General Pest',amount:2800},
    {id:9,month:tm(1),business:'GC',service:'Commercial Disinfection',amount:3800},
    {id:10,month:tm(1),business:'GC',service:'Mold Treatment',amount:1200},
    {id:11,month:tm(2),business:'GB',service:'Termites',amount:3500},
    {id:12,month:tm(2),business:'GB',service:'Rodents',amount:2200},
    {id:13,month:tm(2),business:'GC',service:'Move-in/Move-out',amount:2800},
    {id:14,month:tm(3),business:'GB',service:'General Pest',amount:2600},
    {id:15,month:tm(3),business:'GB',service:'Mosquitoes',amount:1400},
    {id:16,month:tm(3),business:'GC',service:'Residential Disinfection',amount:1800},
    {id:17,month:tm(4),business:'GB',service:'Rodents',amount:2000},
    {id:18,month:tm(4),business:'GC',service:'Commercial Disinfection',amount:3200},
    {id:19,month:tm(5),business:'GB',service:'General Pest',amount:2200},
    {id:20,month:tm(5),business:'GC',service:'Residential Disinfection',amount:1500},
  ];
  saveRevenue(sampleRevenue);

  // Keywords
  const sampleKeywords=[
    {id:1,keyword:'pest control yuba city',business:'Green Bones',volume:720,currentRank:8,prevRank:12,priority:'High',targetUrl:'/pest-control'},
    {id:2,keyword:'ant control near me',business:'Green Bones',volume:480,currentRank:15,prevRank:18,priority:'High',targetUrl:'/ants'},
    {id:3,keyword:'disinfection services yuba city',business:'Green Clean',volume:210,currentRank:5,prevRank:7,priority:'High',targetUrl:'/disinfection'},
    {id:4,keyword:'rodent control marysville ca',business:'Green Bones',volume:320,currentRank:11,prevRank:11,priority:'Medium',targetUrl:'/rodents'},
    {id:5,keyword:'commercial cleaning yuba sutter',business:'Green Clean',volume:170,currentRank:9,prevRank:14,priority:'Medium',targetUrl:'/commercial'},
    {id:6,keyword:'termite inspection yuba city',business:'Green Bones',volume:390,currentRank:22,prevRank:25,priority:'High',targetUrl:'/termites'},
    {id:7,keyword:'mold treatment sacramento valley',business:'Green Clean',volume:140,currentRank:18,prevRank:20,priority:'Low',targetUrl:'/mold'},
  ];
  saveKeywords(sampleKeywords);

  // Blog posts
  saveBlogPosts([
    {id:1,title:'Spring Ant Prevention: 10 Tips for Yuba City Homeowners',business:'Green Bones Pest Control',keyword:'ant prevention yuba city',status:'Published',wordCount:1450,date:td(15),content:''},
    {id:2,title:'Why Commercial Disinfection Matters Post-COVID',business:'Green Clean Disinfectants',keyword:'commercial disinfection',status:'Review',wordCount:1200,date:td(5),content:''},
    {id:3,title:'Rodent-Proofing Your Home Before Winter',business:'Green Bones Pest Control',keyword:'rodent proofing',status:'Idea',wordCount:0,date:td(2),content:''},
  ]);

  // Reviews
  saveReviews([
    {id:1,platform:'Google',business:'Green Bones Pest Control',rating:5,customer:'Sarah J.',text:'Amazing service! They got rid of our ant problem in one visit. Highly recommend!',date:td(3),responseStatus:'Responded'},
    {id:2,platform:'Yelp',business:'Green Bones Pest Control',rating:4,customer:'Mike T.',text:'Good work on the rodent issue. Came out quickly and was very thorough.',date:td(10),responseStatus:'Responded'},
    {id:3,platform:'Google',business:'Green Clean Disinfectants',rating:5,customer:'Linda P.',text:'Our office has never been cleaner. Professional team and great attention to detail.',date:td(7),responseStatus:'Needs Response'},
    {id:4,platform:'Facebook',business:'Green Bones Pest Control',rating:2,customer:'John D.',text:'Had to call back twice for the same spider problem. Disappointed with the follow-up.',date:td(14),responseStatus:'Needs Response'},
    {id:5,platform:'Nextdoor',business:'Green Bones Pest Control',rating:5,customer:'Karen W.',text:'Best pest control in the area! Been using them for 3 years now.',date:td(20),responseStatus:'Responded'},
    {id:6,platform:'Google',business:'Green Clean Disinfectants',rating:5,customer:'Amy C.',text:'Did an incredible job on our post-renovation cleanup. Worth every penny!',date:td(8),responseStatus:'Responded'},
  ]);

  // Competitors
  saveCompetitors([
    {id:1,name:'ABC Pest Control',services:'General pest, rodents, termites',pricing:'$150-500',googleRating:4.2,reviewCount:87,strengths:'Long established, good pricing',weaknesses:'Slow response time, limited services'},
    {id:2,name:'Valley Exterminators',services:'Full pest control, wildlife',pricing:'$200-800',googleRating:4.5,reviewCount:145,strengths:'Many reviews, fast service',weaknesses:'Higher prices, no disinfection services'},
    {id:3,name:'Quick Kill Pest',services:'General pest, ants, spiders',pricing:'$100-300',googleRating:3.8,reviewCount:42,strengths:'Low prices',weaknesses:'Poor reviews, limited scope'},
  ]);

  // Social posts
  saveSocialPosts([
    {id:1,platform:'Facebook',business:'Green Bones Pest Control',date:td(0),status:'Approved',content:'Spring is here and so are the ants! Call Green Bones for a free inspection.'},
    {id:2,platform:'Instagram',business:'Green Clean Disinfectants',date:td(1),status:'Draft',content:'Sparkling clean offices start with Green Clean. Book your spring deep clean today!'},
    {id:3,platform:'TikTok',business:'Green Bones Pest Control',date:td(2),status:'Posted',content:'POV: You find a spider in your bathroom at 2am... Call Green Bones, we handle it!'},
  ]);

  // Engagement
  saveEngagement([
    {id:1,platform:'Facebook',date:td(7),reach:1250,likes:45,comments:12,shares:8,clicks:32,leads:3},
    {id:2,platform:'Instagram',date:td(7),reach:890,likes:67,comments:5,shares:3,clicks:18,leads:1},
    {id:3,platform:'TikTok',date:td(7),reach:4500,likes:230,comments:34,shares:45,clicks:67,leads:4},
    {id:4,platform:'Nextdoor',date:td(7),reach:620,likes:15,comments:8,shares:2,clicks:22,leads:5},
    {id:5,platform:'Facebook',date:td(14),reach:1100,likes:38,comments:9,shares:6,clicks:28,leads:2},
    {id:6,platform:'TikTok',date:td(14),reach:3800,likes:190,comments:28,shares:38,clicks:52,leads:3},
  ]);

  // Campaigns
  saveCampaigns([
    {id:1,title:'Spring Ant Blitz',business:'Green Bones Pest Control',platform:'TikTok',duration:'30',script:'Hook: "Your kitchen is being invaded..." Show ants marching, then Green Bones truck arrives.',status:'Script',views:0,clicks:0,leads:0},
    {id:2,title:'Clean Office = Happy Office',business:'Green Clean Disinfectants',platform:'Facebook',duration:'15',script:'Quick montage of dirty vs clean office spaces. End with Green Clean logo.',status:'Planning',views:0,clicks:0,leads:0},
  ]);

  // Ad performance
  saveAdPerf([
    {id:1,name:'FB Spring Pest Campaign',platform:'Facebook',spend:250,impressions:12000,clicks:340,leads:8,revenue:2400},
    {id:2,name:'Google Ads - Pest Control',platform:'Google',spend:400,impressions:8000,clicks:420,leads:12,revenue:4200},
    {id:3,name:'TikTok Promote - Spider Video',platform:'TikTok',spend:50,impressions:15000,clicks:280,leads:3,revenue:750},
  ]);

  // API costs
  saveApiCosts([
    {id:1,date:td(1),service:'Claude API',cost:2.45},
    {id:2,date:td(2),service:'Claude API',cost:1.80},
    {id:3,date:td(3),service:'ElevenLabs',cost:5.00},
    {id:4,date:td(5),service:'Brave Search',cost:0.50},
    {id:5,date:td(7),service:'Claude API',cost:3.20},
  ]);

  // Activity
  DB.set('activity',[
    {text:'New lead: Jessica Lee (GB - Bed Bugs)',module:'leads',time:new Date().toISOString()},
    {text:'Blog post generated: Spring Ant Prevention',module:'seo',time:new Date(Date.now()-86400000).toISOString()},
    {text:'Social content generated for TikTok',module:'social',time:new Date(Date.now()-172800000).toISOString()},
    {text:'Review response generated for John D.',module:'reviews',time:new Date(Date.now()-259200000).toISOString()},
    {text:'Lead WON: Mike Thompson ($600)',module:'leads',time:new Date(Date.now()-345600000).toISOString()},
  ]);
}

// ==================== WINSTON LIVE DATA FEED ====================
let winstonData = null;

async function fetchWinstonData(){
  try{
    // Fetch live data from WordPress REST API (base64-encoded in WP page)
    const res = await fetch('https://greenbonespestcontrol.com/wp-json/wp/v2/pages?slug=winston-data&_fields=content&t='+Date.now());
    if(!res.ok) throw new Error('HTTP '+res.status);
    const pages = await res.json();
    if(!pages.length) throw new Error('No data page found');
    const html = pages[0].content.rendered;
    const match = html.match(/<pre id="winston-data">([\s\S]*?)<\/pre>/);
    if(!match) throw new Error('No data block in page');
    winstonData = JSON.parse(atob(match[1].trim()));
    renderWinstonPanel();
  }catch(e){
    console.log('Winston data not available:',e.message);
    // Try health page as fallback
    try{
      const hres = await fetch('https://greenbonespestcontrol.com/wp-json/wp/v2/pages?slug=winston-health&_fields=content&t='+Date.now());
      if(hres.ok){
        const hpages = await hres.json();
        if(hpages.length){
          const hhtml = hpages[0].content.rendered;
          const hmatch = hhtml.match(/<pre id="winston-data">([\s\S]*?)<\/pre>/);
          if(hmatch) showWinstonStatus(JSON.parse(atob(hmatch[1].trim())));
        }
      }
    }catch(e2){}
  }
}

function renderWinstonPanel(){
  const panel = document.getElementById('winston-live-panel');
  if(!panel || !winstonData) return;
  panel.style.display='block';

  const leads = winstonData.leads || {};
  const sys = winstonData.system_status || {};
  const lastUpdated = winstonData.last_updated;

  // Connection status
  const dot = document.getElementById('winston-status-dot');
  const label = document.getElementById('winston-status-label');
  const updateEl = document.getElementById('winston-last-update');
  if(lastUpdated){
    const mins = Math.floor((Date.now() - new Date(lastUpdated).getTime()) / 60000);
    if(mins < 20){
      dot.style.background='var(--success)'; label.textContent='Live'; label.style.color='var(--success)';
    }else if(mins < 60){
      dot.style.background='var(--warn)'; label.textContent='Delayed ('+mins+'m ago)'; label.style.color='var(--warn)';
    }else{
      dot.style.background='var(--danger)'; label.textContent='Offline'; label.style.color='var(--danger)';
    }
    updateEl.textContent='Updated: '+new Date(lastUpdated).toLocaleString();
  }

  // KPI values
  document.getElementById('wl-total').textContent = leads.total_all_time || 0;
  document.getElementById('wl-today').textContent = leads.today || 0;
  document.getElementById('wl-week').textContent = leads.this_week || 0;
  document.getElementById('wl-month').textContent = leads.this_month || 0;
  document.getElementById('wl-score').textContent = (leads.conversion_metrics||{}).avg_lead_score || '—';
  document.getElementById('wl-top-src').textContent = ((leads.conversion_metrics||{}).top_performing_source || '—').charAt(0).toUpperCase()+((leads.conversion_metrics||{}).top_performing_source||'').slice(1);

  // Source badges
  const srcEl = document.getElementById('wl-sources');
  if(srcEl && leads.by_source){
    const colors={nextdoor:'#8ED500',facebook:'#1877F2',craigslist:'#6E3FAF',reddit:'#FF4500',yelp:'#D32323',angi:'#FF6138',google:'#4285F4',website:'#2D6A2D'};
    srcEl.innerHTML = Object.entries(leads.by_source).map(([k,v])=>
      `<span style="padding:3px 10px;border-radius:12px;font-size:11px;font-weight:600;background:${colors[k]||'#666'}22;color:${colors[k]||'#999'}">${k}: ${v}</span>`
    ).join('');
  }

  // Recent leads
  const recentEl = document.getElementById('wl-recent');
  if(recentEl && leads.recent_leads && leads.recent_leads.length){
    recentEl.innerHTML = '<div style="font-size:12px;font-weight:600;color:var(--text2);margin-bottom:6px">RECENT LEADS FROM WINSTON</div>' +
      leads.recent_leads.slice(0,8).map(l=>{
        const scoreColor = l.score>=8?'var(--success)':l.score>=5?'var(--warn)':'var(--danger)';
        return `<div style="display:flex;align-items:center;gap:10px;padding:4px 0;border-bottom:1px solid var(--border)">
          <span style="font-weight:700;color:${scoreColor};min-width:24px;text-align:center">${l.score}</span>
          <span style="font-size:12px"><strong>${l.platform}</strong> · ${l.author||'Unknown'} · ${l.location||''} · ${l.pest_type||''}</span>
          <span style="font-size:11px;color:var(--text2);margin-left:auto">${l.timestamp?new Date(l.timestamp).toLocaleDateString():''}</span>
        </div>`}).join('');
  }
}

function showWinstonStatus(health){
  const panel = document.getElementById('winston-live-panel');
  if(!panel) return;
  panel.style.display='block';
  const dot = document.getElementById('winston-status-dot');
  const label = document.getElementById('winston-status-label');
  if(health.last_push){
    const mins = Math.floor((Date.now() - new Date(health.last_push).getTime()) / 60000);
    if(mins<20){dot.style.background='var(--success)';label.textContent='Live';label.style.color='var(--success)'}
    else if(mins<60){dot.style.background='var(--warn)';label.textContent='Delayed';label.style.color='var(--warn)'}
    else{dot.style.background='var(--danger)';label.textContent='Offline';label.style.color='var(--danger)'}
  }
}

// Fetch Winston data on load and every 60 seconds
setInterval(fetchWinstonData, 60000);

// ==================== INITIALIZATION ====================
function initApp(){
  renderSidebar();
  navigateTo('dashboard');
  fetchWinstonData();  // Fetch live data from Winston
  // Auto-load sample data on first visit
  if(!DB.get('initialized')){
    loadSampleData();
    DB.set('initialized',true);
    navigateTo('dashboard');
  }
}

// Check session
if(sessionStorage.getItem('gbgc_auth')==='true'){
  document.getElementById('login-screen').style.display='none';
  document.getElementById('app').style.display='flex';
  document.getElementById('ai-chat-btn').style.display='flex';
  initApp();
}
</script>
</body>
</html>