{compact && ( )} {compact && (

A {activeDeal ? `${activeDeal.company} · ${activeDeal.stage}` : contextLabel}

)} {hasThread && (

{messages.map((m, i) => (

{m.role === "addy" && A}

{m.text}

))} {thinking && (

thinking…

)}

)} {showStarters && starters.length > 0 && (

{starters.map((s, i) => ( ))}

)} {slashOpen && slashMatches.length > 0 && ( )}

{suggestion && !hasThread && !slashOpen && ( )}

setVal(e.target.value)}
          onKeyDown={onKeyDown}
        />
        <button className="btn ghost sm" type="button" tabIndex={-1}><Icon name="mic" size={14} /></button>
        <button
          className="send"
          type="button"
          disabled={!trimmed}
          onClick={() => submit(val)}
          aria-label="Send message"
        >
          <Icon name="arrow" size={14} />
        </button>
      </div>
    </div>
  );
};

// ---------- Sidebar ----------
const Sidebar = ({ route, setRoute, theme, setTheme, nudgeCount,
                   dashboardView = "ae", setDashboardView,
                   managerSection = "home", setManagerSection,
                   addyState = "idle", addyUnread = 0,
                   expanded = false, onToggleExpanded,
                   profile, workspace, onOpenSettings }) => {
  const isManager = dashboardView === "manager";
  const profileName = profile?.name || "Ridha Mansour";
  const profileFirst = profileName.split(/\s+/)[0] || "Ridha";
  const profileEmail = profile?.email || "ridha@addvocate.ai";
  const profileInitial = (profileName.trim()[0] || "R").toUpperCase();
  const [profileOpen, setProfileOpen] = useState(false);
  const profileRef = useRef(null);
  useEffect(() => {
    if (!profileOpen) return;
    const onClick = (e) => {
      if (profileRef.current && !profileRef.current.contains(e.target)) setProfileOpen(false);
    };
    const onKey = (e) => { if (e.key === "Escape") setProfileOpen(false); };
    document.addEventListener("mousedown", onClick);
    document.addEventListener("keydown", onKey);
    return () => {
      document.removeEventListener("mousedown", onClick);
      document.removeEventListener("keydown", onKey);
    };
  }, [profileOpen]);
  // Addy is no longer a destination — she lives in the logo dots (click
  // them or press ⌘K to summon the spotlight). The "Promises" entry was
  // also removed: the spotlight IS the commitment register. Everything
  // Addy is doing/did/will do is reachable from the logo.
  // Icons map to what the section actually does, not just the route name:
  //   home (AE)        → bolt    : today's action-ranked command center
  //   deals            → eye     : Deal Truth — seeing seller vs buyer truth
  //   analytics        → trend   : drop-off charts and won/lost patterns
  //   home (Manager)   → users   : team cockpit lens
  //   deals (Manager)  → eye     : same Deal Truth lens, across the team
  //   config (Manager) → sliders : forecast model configuration
  // Labels mirror the section's header title verbatim.
  const aeItems = [
    { k: "home",      icon: "bolt",  label: "Today's deal command" },
    { k: "deals",     icon: "eye",   label: "Deal Truth" },
    { k: "analytics", icon: "trend", label: "Analytics" },
  ];
  const managerItems = [
    { k: "home",   icon: "users", label: "Team forecast cockpit" },
    { k: "deals",  icon: "eye",   label: "Deal forecast review" },
    { k: "config", icon: "trend", label: "Analytics" },
  ];
  const primaryItems = isManager ? managerItems : aeItems;
  const handlePrimaryClick = (key) => {
    if (isManager) {
      if (route !== "home") setRoute("home");
      setManagerSection?.(key);
    } else {
      setRoute(key);
    }
  };
  const isPrimaryActive = (key) => {
    if (isManager) return route === "home" && managerSection === key;
    return route === key;
  };
  const switchView = (view) => {
    if (view === dashboardView) return;
    setDashboardView?.(view);
    if (view === "manager") {
      setRoute("home");
      setManagerSection?.("home");
    } else {
      setRoute("home");
    }
  };

return (
    <div className={`sidebar ${isManager ? "is-manager" : ""} ${expanded ? "is-expanded" : ""}`}>
      {/* Addy lives here. The two dots are her presence — each animates
          per state. Click (or ⌘K) summons the spotlight overlay. */}
      <button
        type="button"
        className="logo"
        data-addy-state={addyState || "idle"}
        aria-label={`Open Addy${addyUnread > 0 ? ` · ${addyUnread} unread` : ""}`}
        title="Addy · ⌘K"
        onClick={() => { if (typeof window.openAddy === "function") window.openAddy(); }}
      >
        <span className="logo-dots" aria-hidden="true">
          <span className="logo-dot logo-dot--1" />
          <span className="logo-dot logo-dot--2" />
          <span className="logo-dot logo-dot--3" />
        </span>
        <span className="logo-wordmark" aria-hidden="true">
          Nudge<sup>®</sup>
        </span>
        {addyUnread > 0 && (
          <span className="logo-badge" aria-hidden="true">{addyUnread}</span>
        )}
      </button>
      {primaryItems.map((i) => (
        <button
          key={i.k}
          className={`nav-btn ${isPrimaryActive(i.k) ? "active" : ""}`}
          title={i.label}
          onClick={() => handlePrimaryClick(i.k)}
        >
          <Icon name={i.icon} />
          <span className="nav-label">{i.label}</span>
        </button>
      ))}
      <div className="spacer" />
      <div className={`sidebar-bottom-controls ${isManager ? "is-manager" : "is-ae"}`}>
        {setDashboardView && (
          <div
            className={`sidebar-mode-switch is-${dashboardView === "manager" ? "mgr" : "ae"}`}
            role="group"
            aria-label="Dashboard mode"
            data-tour="mode-toggle"
          >
            <button
              type="button"
              className={`mode-btn ${dashboardView === "ae" ? "is-active" : ""}`}
              title="AE view"
              aria-label="AE view"
              aria-pressed={dashboardView === "ae"}
              onClick={() => switchView("ae")}
            >
              <Icon name="userx" size={11} />
              <span className="mode-btn-label">AE</span>
            </button>
            <button
              type="button"
              className={`mode-btn ${dashboardView === "manager" ? "is-active" : ""}`}
              title="Manager view"
              aria-label="Manager view"
              aria-pressed={dashboardView === "manager"}
              onClick={() => switchView("manager")}
            >
              <Icon name="users" size={11} />
              <span className="mode-btn-label">MGR</span>
            </button>
          </div>
        )}
        <div
          className={`sidebar-theme-switch is-${theme === "dark" ? "dark" : "light"}`}
          role="group"
          aria-label="Theme"
        >
          <button
            type="button"
            className={`theme-btn ${theme === "dark" ? "is-active" : ""}`}
            title="Dark theme"
            aria-label="Dark theme"
            aria-pressed={theme === "dark"}
            onClick={() => setTheme("dark")}
          >
            <Icon name="moon" size={11} />
            <span className="theme-btn-label">Dark</span>
          </button>
          <button
            type="button"
            className={`theme-btn ${theme === "light" ? "is-active" : ""}`}
            title="Light theme"
            aria-label="Light theme"
            aria-pressed={theme === "light"}
            onClick={() => setTheme("light")}
          >
            <Icon name="sun" size={11} />
            <span className="theme-btn-label">Light</span>
          </button>
        </div>
        <div className="sidebar-profile" ref={profileRef}>
          <button
            type="button"
            className={`sidebar-profile-trigger ${profileOpen ? "is-open" : ""}`}
            title={`Account · ${profileFirst}`}
            aria-label={`Account · ${profileFirst}`}
            aria-haspopup="menu"
            aria-expanded={profileOpen}
            onClick={() => setProfileOpen((v) => !v)}
          >
            <span className="sidebar-profile-avatar" aria-hidden="true">
              {profileInitial}
              <span className="sidebar-profile-status" aria-hidden="true" />
            </span>
            <span className="sidebar-profile-trigger-id">
              <b>{profileFirst}</b>
              <em>{profileEmail}</em>
            </span>
          </button>
          {profileOpen && (
            <div className="sidebar-profile-menu" role="menu" aria-label="Account">
            <div className="sidebar-profile-menu-head">
              <span className="sidebar-profile-avatar lg" aria-hidden="true">{profileInitial}</span>
              <div className="sidebar-profile-menu-id">
                <b>{profileFirst}</b>
                <em>{profileEmail}</em>
                {workspace?.name && <em>{workspace.name}</em>}
              </div>
            </div>
            <button type="button" className="sidebar-profile-menu-item" role="menuitem" onClick={() => setProfileOpen(false)}>
              <Icon name="chat" size={14} /> Help & support
            </button>
            <span className="sidebar-profile-menu-sep" aria-hidden="true" />
            <button type="button" className="sidebar-profile-menu-item is-signout" role="menuitem" onClick={() => setProfileOpen(false)}>
              <Icon name="arrow" size={14} /> Sign out
            </button>
            </div>
          )}
        </div>
      </div>
      {onToggleExpanded && (
        <button
          type="button"
          className="sidebar-toggle"
          title={expanded ? "Collapse sidebar" : "Expand sidebar"}
          aria-label={expanded ? "Collapse sidebar" : "Expand sidebar"}
          aria-pressed={expanded}
          onClick={onToggleExpanded}
        >
          <Icon name={expanded ? "chevronL" : "chevronR"} />
          <span className="nav-label">Collapse</span>
        </button>
      )}
    </div>
  );
};

// ---------- Buyer Forecast ----------
// Daily "weather report" for buyer and seller progression. Shows once on
// the first connection of the day (tracked in localStorage), and can be
// re-opened any time from the sidebar toggle. Mounts/unmounts with a
// scale + fade animation.
const FORECAST_KEY = "nudge.forecast.lastShown";
const todayKey = () => {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
};
const shouldShowForecastToday = () => {
  try {
    return localStorage.getItem(FORECAST_KEY) !== todayKey();
  } catch (_) {
    return true;
  }
};
const markForecastShown = () => {
  try { localStorage.setItem(FORECAST_KEY, todayKey()); } catch (_) {}
};

const BuyerForecast = ({ open, onClose, deals = [], onOpenDeal }) => {
  const [render, setRender] = useState(open);
  const [closing, setClosing] = useState(false);

useEffect(() => {
    if (open) {
      setRender(true);
      setClosing(false);
      return undefined;
    }
    if (render) {
      setClosing(true);
      const t = setTimeout(() => {
        setRender(false);
        setClosing(false);
      }, 320);
      return () => clearTimeout(t);
    }
    return undefined;
  }, [open, render]);

useEffect(() => {
    if (!open) return undefined;
    const onKey = (e) => { if (e.key === "Escape") onClose && onClose(); };
    window.addEventListener("keydown", onKey);
    return () => window.removeEventListener("keydown", onKey);
  }, [open, onClose]);

const forecast = useMemo(() => buildForecast(deals), [deals]);
  if (!render) return null;

const today = new Date().toLocaleDateString(undefined, { weekday: "long", month: "long", day: "numeric" });

return (
    <div
      className={`forecast-backdrop ${closing ? "is-closing" : "is-opening"}`}
      role="dialog"
      aria-modal="true"
      aria-labelledby="forecast-title"
      onClick={onClose}
    >
      <div className={`forecast-card tone-${forecast.verdict.kind}`} onClick={(e) => e.stopPropagation()}>
        <button type="button" className="forecast-close" onClick={onClose} aria-label="Dismiss forecast">
          <Icon name="close" size={14} />
        </button>
        <div className="forecast-eyebrow">
          <span>Today's progression forecast</span>
          <span className="mono sub">{today}</span>
        </div>
        <div className="forecast-hero">
          <WeatherGlyph kind={forecast.verdict.kind} size={64} />
          <div className="forecast-hero-text">
            <h2 id="forecast-title" className="forecast-title">{forecast.verdict.title}</h2>
            <p className="forecast-sub">{forecast.verdict.sub}</p>
          </div>
        </div>
        <ul className="forecast-list">
          {forecast.items.map((it) => {
            const sign = it.delta > 0 ? "+" : "";
            const bandLeft = Math.min(it.buyer, it.seller);
            const bandWidth = Math.abs(it.seller - it.buyer);
            return (
              <li key={it.id}>
                <button
                  type="button"
                  className={`forecast-row tone-${it.weather.tone}`}
                  onClick={() => { onOpenDeal && onOpenDeal(it.id); onClose && onClose(); }}
                  title={`Open ${it.company}`}
                >
                  <WeatherGlyph kind={it.weather.kind} size={28} />
                  <div className="forecast-row-text">
                    <div className="forecast-row-top">
                      <div>
                        <div className="forecast-row-co">{it.company}</div>
                        <div className="forecast-row-meta">{it.stage} · {it.distance}</div>
                      </div>
                      <div className={`forecast-row-delta tone-${it.weather.tone}`}>
                        <span>{sign}{it.delta}</span>
                        <em>buyer 7d</em>
                      </div>
                    </div>
                    <div className="forecast-path" aria-hidden="true">
                      <span className="forecast-path-gap" style={{ left: `${bandLeft}%`, width: `${bandWidth}%` }} />
                      <span className="forecast-path-marker buyer" style={{ left: `${it.buyer}%` }}>
                        <b>B</b>
                        <em>{it.buyer}</em>
                      </span>
                      <span className="forecast-path-marker seller" style={{ left: `${it.seller}%` }}>
                        <b>S</b>
                        <em>{it.seller}</em>
                      </span>
                      <span className="forecast-path-target">Target</span>
                    </div>
                  </div>
                </button>
              </li>
            );
          })}
          {forecast.items.length === 0 && (
            <li className="forecast-empty">No open deals to forecast yet.</li>
          )}
        </ul>
        <div className="forecast-foot">
          <span className="muted">Buyer and seller share one path to close. The forecast shows distance on that path.</span>
          <button type="button" className="btn sm" onClick={onClose}>Got it</button>
        </div>
      </div>
    </div>
  );
};

// ---------- Evidence drawer ----------
const sourceMeta = (source = "") => {
  const key = source.toLowerCase();
  if (/salesforce|crm/.test(key)) return { label: "Salesforce", mark: "SF", tone: "salesforce", slug: "salesforce", color: "00A1E0" };
  if (/gong|call/.test(key)) return { label: "Gong", mark: "G", tone: "gong", slug: "gong", color: "8039DF" };
  if (/slack/.test(key)) return { label: "Slack", mark: "S", tone: "slack", slug: "slack", color: "4A154B" };
  if (/gmail|mail|email|inbox/.test(key)) return { label: "Gmail", mark: "M", tone: "gmail", slug: "gmail", color: "EA4335" };
  if (/calendar|meet/.test(key)) return { label: "Calendar", mark: "C", tone: "calendar", slug: "googlecalendar", color: "4285F4" };
  if (/linkedin/.test(key)) return { label: "LinkedIn", mark: "in", tone: "linkedin", slug: "linkedin", color: "0A66C2" };
  if (/outreach|sequence/.test(key)) return { label: "Outreach", mark: "O", tone: "outreach", slug: null };
  return { label: source || "Source", mark: "N", tone: "nudge", slug: null };
};

const latestActivity = (deal, kind) => (deal?.activity || []).find((item) => item.kind === kind);
const latestMeeting = (deal, past = true) => (deal?.meetings || []).find((meeting) => !!meeting.isPast === past) || (deal?.meetings || [])[0];

if (n.evidence) {
    sources.push({
      source: n.evidence.source || "LinkedIn",
      label: n.evidence.label || "Signal detected",
      time: n.evidence.time || "Recent",
      detail: n.evidence.detail || n.title || "External signal matched",
      proof: n.evidence.proof || n.sub || "Addy matched this external signal against the active deal context.",
    });
  }

if (/economic buyer|cfo|finance|decision-maker|stakeholder/.test(text)) {
    const missing = (deal?.stakeholders || []).find((s) => s.missing) || (deal?.stakeholders || []).find((s) => /cfo|finance|procurement|legal/i.test(s.role));
    sources.push({
      source: n.automation?.source || "LinkedIn",
      label: "Stakeholder match",
      time: "Live enrichment",
      detail: n.automation?.foundContact
        ? `${n.automation.foundContact.name} · ${n.automation.foundContact.role}`
        : missing
          ? `${missing.name} · ${missing.role}`
          : "Likely finance owner identified",
      proof: n.automation?.foundContact?.signal || "Addy matched the missing buyer role against the account map and recommended an intro path.",
    });
  }

if (/silent|engagement|reply|unopened|proposal|follow-up|commitment/.test(text)) {
    sources.push({
      source: "Gmail",
      label: "Thread signal",
      time: email?.time || n.time || "Recent",
      detail: email ? email.title : n.sub || "Recent buyer engagement changed",
      proof: email?.body || n.body || "Thread activity indicates the buyer has not created matching momentum.",
    });
  }

if (/meeting|calendar|timeline|close plan|workshop|commit/.test(text) || nextMeeting) {
    sources.push({
      source: "Calendar",
      label: nextMeeting && !nextMeeting.isPast ? "Upcoming meeting" : "Meeting history",
      time: (nextMeeting && !nextMeeting.isPast ? nextMeeting.date : meeting?.date) || "Recent",
      detail: (nextMeeting && !nextMeeting.isPast ? nextMeeting.title : meeting?.title) || "Calendar path checked",
      proof: (nextMeeting && !nextMeeting.isPast ? nextMeeting.goal : meeting?.debrief?.summary) || "Addy checked whether the next buyer commitment exists on the calendar.",
    });
  }

if (meeting?.debrief && (/call|meeting|legal|redline|security|budget|qbr|expansion|reference/.test(text) || sources.length < 3)) {
    sources.push({
      source: "Gong",
      label: "Call evidence",
      time: meeting.date,
      detail: meeting.debrief.sentiment || meeting.title,
      proof: meeting.debrief.transcriptExcerpt || meeting.debrief.summary,
    });
  }

if (/playbook|escalat|manager|legal|slack|internal/.test(text) || sources.length < 4) {
    sources.push({
      source: "Slack",
      label: "Team context",
      time: "Today",
      detail: n.kind || "Internal coordination",
      proof: diag?.fix || n.action || "No owned internal next step is recorded yet, so Addy is turning the signal into an assignable action.",
    });
  }

if (draft?.workflowSource && !sources.some((item) => item.source === draft.workflowSource)) {
    sources.push({
      source: draft.workflowSource,
      label: "Automation source",
      time: "Live enrichment",
      detail: draft.workflowSummary || `${draft.recipientName} · ${draft.recipientRole}`,
      proof: draft.contactSignal || "The workflow source supplied the enriched contact and role evidence for this action.",
    });
  }

return sources.slice(0, 5);
};

const EvidenceDrawer = ({ open, onClose, recommendation, deal, draft }) => {
  const drawerRef = useRef(null);
  const titleId = `evidence-title-${deal?.id || "feed"}-${(recommendation?.kind || recommendation?.title || "recommendation").toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;

useEffect(() => {
    if (!open) return undefined;
    const previous = document.activeElement;
    const onKey = (e) => { if (e.key === "Escape") onClose && onClose(); };
    window.addEventListener("keydown", onKey);
    setTimeout(() => drawerRef.current?.focus(), 0);
    return () => {
      window.removeEventListener("keydown", onKey);
      previous?.focus?.();
    };
  }, [open, onClose]);

if (!open) return null;

const sources = buildRecommendationEvidence({ recommendation, deal, draft });
  const confidence = Math.min(96, 68 + (sources.length * 6) + (deal?.gap ? Math.min(10, Math.abs(deal.gap) / 4) : 0));
  const primary = recommendation?.title || recommendation?.kind || "Addy recommendation";
  const explanation = recommendation?.body || recommendation?.sub || (deal && (DEAL_DIAGNOSIS[deal.id]?.why || deal.summary));

return (
    <div className="evidence-back" onClick={onClose}>
      <aside
        ref={drawerRef}
        className="evidence-drawer"
        onClick={(e) => e.stopPropagation()}
        data-dialog-root="true"
        role="dialog"
        aria-modal="true"
        aria-labelledby={titleId}
        tabIndex={-1}
      >
        <header className="evidence-head">
          <div>
            <span className="eyebrow">Evidence</span>
            <h2 id={titleId}>{primary}</h2>
            {deal && <p>{deal.company} · {deal.stage} · {deal.statusLabel}</p>}
          </div>
          <button type="button" className="btn sm ghost" onClick={onClose} aria-label="Close evidence">
            <Icon name="close" size={14} />
          </button>
        </header>

<div className="evidence-confidence">
          <span>Confidence</span>
          <b>{Math.round(confidence)}%</b>
          <i><span style={{ width: `${confidence}%` }} /></i>
        </div>

{explanation && (
          <section className="evidence-summary">
            <span className="eyebrow">Why Addy surfaced this</span>
            <p>{explanation}</p>
          </section>
        )}

<section className="evidence-sources" aria-label="Evidence sources">
          {sources.map((item, i) => {
            const meta = sourceMeta(item.source);
            return (
              <article key={`${item.source}-${i}`} className="evidence-source">
                <SourceLogo source={item.source} />
                <div>
                  <div className="evidence-source-top">
                    <b>{item.label}</b>
                    <span>{meta.label} · {item.time}</span>
                  </div>
                  <strong>{item.detail}</strong>
                  <p>{item.proof}</p>
                </div>
              </article>
            );
          })}
        </section>

<footer className="evidence-foot">
          <button type="button" className="btn ghost" onClick={onClose}>Dismiss</button>
          <button type="button" className="btn accent" onClick={onClose}>
            Use recommendation <Icon name="arrow" size={13} />
          </button>
        </footer>
      </aside>
    </div>
  );
};

const EvidenceStrip = ({ recommendation, deal, draft, limit = 4, compact = false }) => {
  const [visible, setVisible] = useState(false);
  const [openIndex, setOpenIndex] = useState(null);
  const sources = buildRecommendationEvidence({ recommendation, deal, draft }).slice(0, limit);
  if (!sources.length) return null;
  const selected = openIndex !== null ? sources[openIndex] : null;

return (
    <div className={`evidence-strip ${compact ? "is-compact" : ""}`}>
      <button
        type="button"
        className="evidence-disclosure"
        onClick={() => {
          setVisible((next) => {
            if (next) setOpenIndex(null);
            return !next;
          });
        }}
        aria-expanded={visible}
        aria-label={visible ? "Hide evidence" : "Show evidence"}
        title={visible ? "Hide evidence" : "Show evidence"}
      >
        i
      </button>
      {visible && (
        <>
          <div className="evidence-strip-row" aria-label="Evidence sources">
            {sources.map((item, i) => {
              const meta = sourceMeta(item.source);
              const active = openIndex === i;
              return (
                <button
                  key={`${item.source}-${i}`}
                  type="button"
                  className={`evidence-chip ${active ? "is-active" : ""}`}
                  onClick={() => setOpenIndex(active ? null : i)}
                  aria-expanded={active}
                >
                  <SourceLogo source={item.source} size="sm" />
                  <span>
                    <b>{meta.label}</b>
                    <em>{item.label}</em>
                  </span>
                </button>
              );
            })}
          </div>
          {selected && (
            <div className="evidence-inline-proof">
              <div className="evidence-inline-head">
                <SourceLogo source={selected.source} size="sm" />
                <span>{sourceMeta(selected.source).label} · {selected.time}</span>
              </div>
              <b>{selected.detail}</b>
              <p>{selected.proof}</p>
            </div>
          )}
        </>
      )}
    </div>
  );
};

const trackNudgeEvent = (eventName, payload = {}) => {
  if (window.__NUDGE_DEBUG_EVENTS__) console.info("[nudge:event]", eventName, payload);
};

// ---------- Lens helpers (Deal Truth / Seller / Buyer) ----------
// Pillars are ordered to match the on-screen coverage strip.
const MEDDPICC_PILLARS = [
  { code: "M",  label: "Metrics",          re: /\b(roi|metric|kpi|payback|business case|value driver|cost saving|numbers|quantif)/i },
  { code: "E",  label: "Economic buyer",   re: /\b(cfo|chief financial|economic buyer|signing authority|budget approval|procurement signoff|finance)\b/i },
  { code: "DC", label: "Decision criteria",re: /\b(criteria|evaluation|eval checklist|requirements|comparison|compare|scorecard|fit)\b/i },
  { code: "DP", label: "Decision process", re: /\b(decision process|timeline|close date|mutual action|next step|approval path|stages|milestone)\b/i },
  { code: "PP", label: "Paper process",    re: /\b(redline|legal|procurement|contract|msa|paper|signing|dpa|security review)\b/i },
  { code: "IP", label: "Identify pain",    re: /\b(pain|challenge|issue|problem|bottleneck|friction|stall|risk|blocker)\b/i },
  { code: "CH", label: "Champion",         re: /\b(champion|advocate|mobilizer|intro|introduce|coach)\b/i },
  { code: "CO", label: "Competition",      re: /\b(competitor|displacement|linnworks|northline|battlecard|vs\.?|versus|evaluating)\b/i },
];

const SELLER_ACTORS = /^(you|ridha|addy)$/i;
const isSellerActor = (actor = "") => SELLER_ACTORS.test(actor.trim());
const isMixedActor = (actor = "") => /\+/.test(actor) && /you|ridha/i.test(actor);

function activitySide(item, deal) {
  const actor = item.actor || "";
  if (item.kind === "addy") return "ai";
  if (isMixedActor(actor)) return "mixed";
  if (isSellerActor(actor)) return "seller";
  // Match against any stakeholder name (or champion fallback).
  const buyerNames = [(deal?.champion || ""), ...(deal?.stakeholders || []).map((s) => s.name)].filter(Boolean);
  const isBuyer = buyerNames.some((n) => actor.toLowerCase().includes(n.toLowerCase()));
  return isBuyer ? "buyer" : "seller";
}

// Try to extract a buyer commitment from a buyer-side activity body. If we
// can't parse a clean commitment, fall back to the title.
function extractBuyerCommitment(item) {
  const body = item.body || "";
  // Look for "agreed to ...", "confirmed ...", "will ...", "by <date> ..."
  const patterns = [
    /agreed (?:to |on |that )([^.]+)/i,
    /confirmed (?:that |budget )?([^.]+)/i,
    /committed to ([^.]+)/i,
    /will ([^.]+? by [^.]+)/i,
    /(?:i'?ll|we'?ll) ([^.]+)/i,
  ];
  for (const re of patterns) {
    const m = body.match(re);
    if (m) return m[1].trim().replace(/\s+/g, " ");
  }
  return item.title || "Engagement";
}

// Partition activity into seller/buyer/mixed/ai with derived fields.
function partitionLensActivity(deal) {
  const items = (deal?.activity || []).map((it) => {
    const side = activitySide(it, deal);
    return {
      ...it,
      side,
      meddpicc: getActivityMeddpicc(it, deal),
    };
  });
  const seller = items.filter((it) => it.side === "seller" || it.side === "ai" || it.side === "mixed");
  const buyer  = items.filter((it) => it.side === "buyer" || it.side === "mixed").map((it) => ({
    ...it,
    commitment: extractBuyerCommitment(it),
  }));
  // Coverage = unique pillars touched by seller-side activity.
  const sellerCoverage = new Set();
  seller.forEach((it) => it.meddpicc.forEach((c) => sellerCoverage.add(c)));
  const coveredPillars = MEDDPICC_PILLARS.map((p) => ({ ...p, covered: sellerCoverage.has(p.code) }));
  return { seller, buyer, coveredPillars };
}

// Multi-stakeholder champion classification for the buyer lens.
// Returns one entry per engaged stakeholder, plus an `expansion` count
// indicating how many internal stakeholders the buyer has pulled in beyond
// the primary champion.
function classifyChampions(deal) {
  const stakeholders = (deal?.stakeholders || []).filter((s) => !s.missing);
  if (stakeholders.length === 0) return { roles: [], expansion: 0, primaryName: null };

const championName = deal?.champion;
  const ranked = [...stakeholders].sort(
    (a, b) => ((b.power || 0) * 2 + (b.support || 0)) - ((a.power || 0) * 2 + (a.support || 0))
  );

// Primary champion: explicit name match wins; otherwise top-ranked engaged stakeholder
  // whose support is high enough to count.
  let primary = championName ? ranked.find((s) => s.name === championName) : null;
  if (!primary) primary = ranked.find((s) => (s.support || 0) >= 4) || ranked[0];

const expansion = roles.filter((r) => !r.isPrimary).length;
  return { roles, expansion, primaryName: primary?.name || null };
}

// Follow-through: did the buyer's stated commitment actually translate into
// downstream activity? Pulls 1-2 distinctive nouns from the commitment text
// and scans activity items recorded *after* the commitment for a topical
// match. Activity arrays are reverse-chronological in the seed data, so
// "later in time" means "earlier index" in the array.
const COMMITMENT_STOPWORDS = /^(the|a|an|to|on|in|at|by|for|with|of|and|or|that|this|will|can|could|would|should|i|we|our|their|next|some|any|been|done|have|has|had|been|us|them|so|but|if|as)$/i;
function commitmentTopics(commitment = "") {
  const words = String(commitment).toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4 && !COMMITMENT_STOPWORDS.test(w));
  // Dedupe, keep insertion order, cap at 3 tokens.
  return Array.from(new Set(words)).slice(0, 3);
}
function findFollowThrough(commitment, item, allItems = []) {
  const topics = commitmentTopics(commitment);
  if (topics.length === 0) return null;
  const idx = allItems.indexOf(item);
  if (idx <= 0) return null;
  // Activity array is reverse-chronological. Items "later in time" sit at
  // smaller indices. We want activity newer than `item` — slice(0, idx).
  const newer = allItems.slice(0, idx);
  for (const candidate of newer) {
    if (candidate === item) continue;
    const haystack = `${candidate.title || ""} ${candidate.body || ""}`.toLowerCase();
    const matchedTopic = topics.find((t) => haystack.includes(t));
    if (matchedTopic) {
      return { matched: true, item: candidate, topic: matchedTopic };
    }
  }
  return { matched: false, topics };
}

const CHAMPION_ROLE_LABEL = {
  "primary-champion": "Primary champion",
  "co-champion": "Co-champion",
  "mobilizer": "Mobilizer",
  "sponsor": "Executive sponsor",
  "blocker-risk": "Blocker risk",
  "supporter": "Supporter",
};
const CHAMPION_ROLE_TONE = {
  "primary-champion": "good",
  "co-champion": "good",
  "mobilizer": "info",
  "sponsor": "amber",
  "blocker-risk": "warn",
  "supporter": "muted",
};

const getDealDefense = (deal) => {
  if (!deal) {
    return {
      state: "Unknown",
      tone: "unknown",
      reason: "No deal context available.",
      recommendedAction: "Add evidence before defending this deal.",
      buyerNextStep: "unknown",
      decisionOwner: "unknown",
      approvalPath: "unknown",
      evidence: "unknown",
      riskLabel: "Buyer proof unknown",
      buyerName: "",
      checks: {},
      evidenceItems: [],
    };
  }

const upcomingMeeting = meetings.find((m) => !m.isPast);
  const pastMeetingWithNextStep = meetings.find((m) => m.isPast && (m.debrief?.nextSteps || m.intel?.talkingPoints));
  const buyerActivity = activity.find((a) => /buyer|milestone/i.test(a.tag || "") || /replied|confirmed|signed|asked|agreed|accepted|approved/i.test(`${a.title} ${a.body}`));
  const decisionOwnerRecord = activeDecisionOwner(stakeholders);
  const championRecord = fallbackChampion(stakeholders);
  const missingOwner = stakeholders.find((s) => s.missing && /cfo|economic|decision|finance|operations/i.test(s.role || ""));
  const approvalSignal = latestMatching([...activity, ...meetings], /approval|procurement|legal|security|signoff|redline|budget|signed|countersigned/i);
  const positiveEvidence = buyerActivity || upcomingMeeting || approvalSignal;

const buyerNextStepCheck = upcomingMeeting
    ? check("present", `${upcomingMeeting.title} · ${upcomingMeeting.date}`, "Calendar")
    : pastMeetingWithNextStep
      ? check("partial", `${pastMeetingWithNextStep.title} produced next steps, but no future meeting is booked`, "Gong")
      : silenceSignal
        ? check("missing", "No current buyer-owned next step after latest signal", "Gmail")
        : check("unknown", "No dated buyer-owned next step found", "CRM");

const decisionOwnerCheck = championLeft
    ? check("missing", `${deal.champion} changed jobs; replacement owner not confirmed`, "LinkedIn")
    : decisionOwnerRecord
      ? check("present", `${decisionOwnerRecord.name} · ${decisionOwnerRecord.role}`, "CRM")
      : championRecord
        ? check("partial", `${championRecord.name} is supportive, but signing authority is not proven`, "CRM")
        : missingOwner
          ? check("missing", `${missingOwner.role} is marked missing from stakeholder map`, "CRM")
          : missingOwnerSignal
            ? check("missing", "Decision owner not confirmed in account map", "CRM")
            : check("unknown", "No power/contact evidence found", "CRM");

const approvalPathCheck = approvalSignal && approvalGapSignal
    ? check("partial", `${approvalSignal.title || "Approval signal"} exists, but path is still contingent or pending`, /meeting/i.test(approvalSignal.kind || "") ? "Gong" : "CRM")
    : approvalGapSignal
      ? check("missing", "Approval path is flagged as unknown or pending", "CRM")
      : approvalSignal
        ? check("present", `${approvalSignal.title || approvalSignal.dealName || "Approval signal"} · ${approvalSignal.time || approvalSignal.date || "recent"}`, /meeting/i.test(approvalSignal.kind || "") ? "Gong" : "CRM")
      : check("unknown", "No approval, security, legal, or procurement evidence found", "CRM");

const evidenceCheck = externalSignal
    ? check("present", `${externalSignal.evidence.source}: ${externalSignal.evidence.detail}`, externalSignal.evidence.source)
    : positiveEvidence
      ? check("present", `${(buyerActivity || approvalSignal || upcomingMeeting).title || "Buyer signal"} · ${(buyerActivity || approvalSignal || upcomingMeeting).time || (buyerActivity || approvalSignal || upcomingMeeting).date || "recent"}`, "CRM")
      : sellerAhead >= 20 || silenceSignal
        ? check("missing", `Seller score leads buyer by ${Math.max(0, sellerAhead)} pts with no matching buyer proof`, "CRM")
        : check("unknown", "No recent buyer-side evidence found", "CRM");

const buyerNextStep = buyerNextStepCheck.status;
  const decisionOwner = decisionOwnerCheck.status;
  const approvalPath = approvalPathCheck.status;
  const evidence = evidenceCheck.status;
  const missingCount = [buyerNextStep, decisionOwner, approvalPath, evidence].filter((v) => v === "missing").length;
  const presentCount = [buyerNextStep, decisionOwner, approvalPath, evidence].filter((v) => v === "present").length;
  const severeRisk = championLeft || (sellerAhead >= 25 && buyerNextStep !== "present") || (competitorSignal && sellerAhead >= 20);

const evidenceItems = [
    {
      source: "CRM",
      label: "Buyer/seller score",
      detail: `${deal.stage} · buyer ${deal.buyerScore}% vs seller ${deal.sellerScore}% · ${absGap} pt gap`,
      tone: absGap >= 25 ? "warn" : absGap >= 10 ? "amber" : "good",
    },
    externalSignal?.evidence && {
      source: externalSignal.evidence.source,
      label: externalSignal.title,
      detail: externalSignal.evidence.detail,
      proof: externalSignal.evidence.proof,
      tone: "warn",
    },
    buyerActivity && {
      source: buyerActivity.kind === "meeting" ? "Gong" : "Gmail",
      label: buyerActivity.title,
      detail: `${buyerActivity.actor} · ${buyerActivity.time}`,
      proof: buyerActivity.body,
      tone: /confirmed|approved|signed|agreed/i.test(`${buyerActivity.title} ${buyerActivity.body}`) ? "good" : "neutral",
    },
    upcomingMeeting && {
      source: "Calendar",
      label: "Next buyer touch",
      detail: `${upcomingMeeting.title} · ${upcomingMeeting.date}`,
      proof: upcomingMeeting.goal || "Future buyer meeting is on the calendar.",
      tone: "good",
    },
    decisionOwnerCheck.status !== "unknown" && {
      source: decisionOwnerCheck.source,
      label: "Decision coverage",
      detail: decisionOwnerCheck.detail,
      tone: decisionOwnerCheck.status === "present" ? "good" : decisionOwnerCheck.status === "partial" ? "amber" : "warn",
    },
    approvalPathCheck.status !== "unknown" && {
      source: approvalPathCheck.source,
      label: "Approval path",
      detail: approvalPathCheck.detail,
      tone: approvalPathCheck.status === "present" ? "good" : approvalPathCheck.status === "partial" ? "amber" : "warn",
    },
  ].filter(Boolean).slice(0, 6);

const primaryNudge = nudges[0];
  const recommendedAction = primaryNudge?.executeLabel || primaryNudge?.action
    ? `${primaryNudge.executeLabel || primaryNudge.action}: ${primaryNudge.title}.`
    : buyerNextStep === "missing" || buyerNextStep === "unknown"
      ? "Confirm decision owner, approval path, and a dated buyer-owned next step."
      : evidence === "missing"
        ? "Add buyer evidence before defending the forecast."
        : decisionOwner === "missing"
          ? "Confirm the decision owner before manager review."
          : "Use the evidence below to defend why the deal is still real.";

const riskLabel = championLeft
    ? "Champion changed jobs"
    : competitorSignal
      ? "Competitor signal"
      : buyerNextStep === "missing"
    ? "No buyer-owned next step"
    : evidence === "missing"
      ? "No evidence"
      : decisionOwner === "missing"
        ? "No decision owner"
        : "Seller-active, buyer-unverified";

return {
    state,
    tone,
    reason,
    recommendedAction,
    buyerNextStep,
    decisionOwner,
    approvalPath,
    evidence,
    riskLabel,
    buyerName: firstName(deal.champion),
    checks: {
      buyerNextStep: buyerNextStepCheck,
      decisionOwner: decisionOwnerCheck,
      approvalPath: approvalPathCheck,
      evidence: evidenceCheck,
    },
    evidenceItems,
  };
};

// Progress permission — answers "is this deal allowed to progress based on
// buyer proof?". Reuses the existing getDealDefense checks so we don't
// invent a parallel scoring system. Closed deals return null so the UI can
// skip rendering the indicator (the question doesn't apply post-close).
const PROGRESS_PROOF_LABELS = {
  buyerNextStep: "buyer-owned next step",
  decisionOwner: "decision owner",
  approvalPath:  "approval path",
  evidence:      "buyer evidence",
};
const getProgressPermission = (deal) => {
  if (!deal) return null;
  if (/closed/i.test(`${deal.stage || ""} ${deal.statusLabel || ""}`)) return null;

const missingProof = Object.entries(defense.checks || {})
    .filter(([, c]) => c && c.status === "missing")
    .map(([key]) => PROGRESS_PROOF_LABELS[key])
    .filter(Boolean);

// Reason copy — anchored on the buyer-proof question, distinct from the
  // health-style language used by the status badge.
  let reason;
  if (base.state === "allowed") {
    reason = "Buyer-owned next step and supporting proof are in place — this stage is earned.";
  } else if (base.state === "at_risk") {
    reason = "Some buyer proof is present, but key signals are still weak for this stage.";
  } else {
    reason = "Critical buyer proof is missing — this stage is not earned yet.";
  }

return {
    state: base.state,
    label: base.label,
    fullLabel: base.fullLabel,
    icon: base.icon,
    reason,
    missingProof,
    nextMove: defense.recommendedAction || null,
  };
};

// ---------- Top brand row ----------
// Three dots in progressive opacity (the brand mark) + Nudge wordmark.
// Matches the printed brand sheet: light → medium → solid, reading like a
// signal building up.
const Brand = () => (
  <div className="brand">
    <span className="brand-mark" aria-hidden="true">
      <span className="brand-mark-dot brand-mark-dot--1" />
      <span className="brand-mark-dot brand-mark-dot--2" />
      <span className="brand-mark-dot brand-mark-dot--3" />
    </span>
    <span className="brand-wordmark">
      Nudge<sup>®</sup>
    </span>
  </div>
);

// ---------- Ambient background ----------
function ParallaxDots() {
  return (
    <div className="ambient" aria-hidden="true">
      <div className="ambient-vignette" />
    </div>
  );
}

// ---------- Progress gate (deal-room indicator) ----------
// Single small chip in the deal-room header that answers "is this deal
// allowed to progress based on buyer proof?". Click toggles a tiny popover
// with the reason and any missing proof. Hidden on closed deals.
function ProgressGate({ deal, className = "" }) {
  const [open, setOpen] = useState(false);
  const ref = useRef(null);
  const permission = getProgressPermission(deal);

useEffect(() => {
    if (!open) return;
    const handle = (e) => { if (ref.current && !ref.current.contains(e.target)) setOpen(false); };
    document.addEventListener("mousedown", handle);
    return () => document.removeEventListener("mousedown", handle);
  }, [open]);

if (!permission) return null;

return (
    <span className={`progress-gate state-${permission.state} ${className}`} ref={ref}>
      <button
        type="button"
        className="progress-gate-chip"
        onClick={() => setOpen((v) => !v)}
        aria-expanded={open}
        aria-haspopup="dialog"
        aria-label={`${permission.fullLabel} — show details`}
        title={permission.fullLabel}
      >
        <Icon name={permission.icon} size={11} />
        <span>{permission.label}</span>
      </button>
      {open && (
        <div className="progress-gate-pop" role="dialog" aria-label={permission.fullLabel}>
          <div className="progress-gate-pop-h">
            <Icon name={permission.icon} size={12} />
            <b>{permission.fullLabel}</b>
          </div>
          <p className="progress-gate-pop-r">{permission.reason}</p>
          {permission.missingProof.length > 0 && (
            <p className="progress-gate-pop-m">
              <span>Missing</span>{permission.missingProof.join(", ")}
            </p>
          )}
        </div>
      )}
    </span>
  );
}

const DealCategories = (() => {
  const gapCategories = [
    { k: "champion-drift", label: "Champion drift", icon: "userx", short: "Champion", hint: "The internal owner is quiet, left, or looking elsewhere." },
    { k: "stakeholder-missing", label: "Missing stakeholder", icon: "users", short: "Stakeholder", hint: "A buyer, blocker, or signer is not in the deal." },
    { k: "process-blocker", label: "Process blocker", icon: "scale", short: "Process", hint: "Legal, security, procurement, or approval flow is stuck." },
    { k: "value-proof", label: "Value proof gap", icon: "target", short: "Value proof", hint: "The buyer has not validated ROI, urgency, or success proof." },
    { k: "timing-risk", label: "Timing risk", icon: "clock", short: "Timing", hint: "The buyer timeline is slipping or unconfirmed." },
  ];

const actionCategories = [
    { k: "re-engage", label: "Re-engage", icon: "chat", short: "Re-engage", hint: "Restart the buyer conversation with relevant context." },
    { k: "map-stakeholders", label: "Map stakeholders", icon: "route", short: "Map people", hint: "Find the missing champion, blocker, or economic buyer." },
    { k: "unblock-process", label: "Unblock process", icon: "scale", short: "Unblock", hint: "Move legal, security, procurement, or approvals forward." },
    { k: "prove-value", label: "Prove value", icon: "trend", short: "Prove value", hint: "Send proof, ROI, or a business-case asset." },
    { k: "close-expand", label: "Close or expand", icon: "handshake", short: "Close/expand", hint: "Convert momentum into commit, QBR, or expansion." },
  ];

const gapByDeal = {
    atlas: "champion-drift",
    global: "champion-drift",
    techstart: "process-blocker",
    acme: "timing-risk",
    startupco: "stakeholder-missing",
    horizon: "value-proof",
    northstar: "value-proof",
    aurora: "stakeholder-missing",
    pacific: "champion-drift",
    rooted: "stakeholder-missing",
    bluefish: "timing-risk",
    ironbridge: "process-blocker",
  };

const actionByDeal = {
    atlas: "re-engage",
    global: "map-stakeholders",
    techstart: "unblock-process",
    acme: "close-expand",
    startupco: "map-stakeholders",
    horizon: "close-expand",
    northstar: "prove-value",
    aurora: "map-stakeholders",
    pacific: "re-engage",
    rooted: "prove-value",
    bluefish: "re-engage",
    ironbridge: "unblock-process",
  };

const find = (items, key, fallbackKey) =>
    items.find((item) => item.k === key) || items.find((item) => item.k === fallbackKey) || items[0];

const inferGapKey = (deal = {}) => {
    if (gapByDeal[deal.sourceDealId || deal.id]) return gapByDeal[deal.sourceDealId || deal.id];
    const text = textFor(deal);
    if (/champion|quiet|silent|left|changed job|repost|competitor/.test(text)) return "champion-drift";
    if (/cfo|economic buyer|decision-maker|stakeholder|signer|owner|finance/.test(text)) return "stakeholder-missing";
    if (/legal|redline|security|procurement|compliance|approval/.test(text)) return "process-blocker";
    if (/close|date|timeline|timing|slip|scheduled/.test(text)) return "timing-risk";
    return "value-proof";
  };

const inferActionKey = (deal = {}) => {
    if (actionByDeal[deal.sourceDealId || deal.id]) return actionByDeal[deal.sourceDealId || deal.id];
    const text = textFor(deal);
    if (/identify|lookup|find|intro|stakeholder|cfo|economic buyer|decision-maker/.test(text)) return "map-stakeholders";
    if (/legal|redline|security|procurement|compliance|approval|unblock/.test(text)) return "unblock-process";
    if (/commit|close|qbr|expansion|reference/.test(text)) return "close-expand";
    if (/proof|roi|business case|value|case study/.test(text)) return "prove-value";
    return "re-engage";
  };

function getGapCategory(deal) {
    return find(gapCategories, inferGapKey(deal), "value-proof");
  }

function getActionCategory(deal) {
    return find(actionCategories, inferActionKey(deal), "re-engage");
  }

return {
    gapCategories,
    actionCategories,
    getGapCategory,
    getActionCategory,
    DealCategoryChip,
    DealCategoryStrip,
  };
})();

// ---------- Channel layer (tiny) ----------
// Two small components: a static "via {channel}" chip for compact surfaces,
// and a segmented switch the user can use to pick the channel themselves.
// The action stays the same — only the channel (and the draft length/style)
// varies.
function ChannelChip({ channel, label, className = "" }) {
  if (!channel) return null;
  const name = label || (window.CHANNEL_LABEL && window.CHANNEL_LABEL[channel]) || channel;
  const icon = (window.CHANNEL_ICON && window.CHANNEL_ICON[channel]) || "mail";
  return (
    <span className={`ch-chip ${className}`}>
      <Icon name={icon} size={11} />
      via {name}
    </span>
  );
}

Object.assign(window, {
  Icon, Sparkline, AlignmentChart, AIDock, Sidebar, Brand, ParallaxDots, WeatherGlyph,
  SourceLogo, EvidenceDrawer, EvidenceStrip, EvidenceQuote, buildRecommendationEvidence,
  computeGapImpact, formatImpactDollars, sortGapsByImpact,
  computeDealPipelineImpact, sortDealsByPipelineImpact,
  trackNudgeEvent, getDealDefense, isBuyerUnverifiedDeal, defenseStatus,
  BuyerForecast, shouldShowForecastToday, markForecastShown,
  NUDGE_GAP_CATEGORIES: DealCategories.gapCategories,
  NUDGE_ACTION_CATEGORIES: DealCategories.actionCategories,
  getDealGapCategory: DealCategories.getGapCategory,
  getDealActionCategory: DealCategories.getActionCategory,
  DealCategoryChip: DealCategories.DealCategoryChip,
  DealCategoryStrip: DealCategories.DealCategoryStrip,
  ChannelChip, ChannelSwitch,
  getProgressPermission, ProgressGate,
  MEDDPICC_PILLARS, getActivityMeddpicc, partitionLensActivity,
  classifyChampions, CHAMPION_ROLE_LABEL, CHAMPION_ROLE_TONE,
  findFollowThrough, commitmentTopics, activitySide,
});