@gotcos/glasses-server 6.98.0 → 6.99.12

package/server/lib/live-cues-v2-data.ts

@@ -13,6 +13,10 @@
 //     carry a funnel word or a figure of two digits or a percent;
 //   - a one-word alias that is also plain English (pet, dive, music...) is "weak": it counts only beside a funnel word or an
 //     industry word, so "let's dive into the numbers" and "pet project" stay quiet. The bare word "quilt" is never an alias;
+//   - a lead source named in speech ("paid search", "PPC", "events") narrows the note to that source: its rows for the named group,
+//     or the largest industries when no group is named. A source alone fires only for a jargon or multi-word name with a funnel word
+//     or figure; a plain word that is also English (direct, events, email, organic...) counts only beside a named group. A source with
+//     a group fires without a funnel word ("PPC landing pages for thrift"), the way a funnel word alone never could;
 //   - domain (dataArmGate): a Quilt meeting runs it. An unreadable orientation is off. Any other confirmed domain (personal,
 //     Sprocket Rocket, Hermit Crabs...) is off. A meeting with no confirmed domain (most G2 meetings) needs a Quilt signal from
 //     the same evaluation: a Quilt brand or SBU/XBU named, a Quilt-domain memory or note among the candidates, or a Quilt term in
@@ -36,6 +40,7 @@ export const DATA_FACTS_LIMITS = {
   maxBytes: 2_000_000,
   maxGroups: 60,
   maxSources: 400,
+  maxBudgetLines: 400,
   /** The speech the trigger reads: the last this many characters of the window (about 100 words). */
   recentChars: 600,
   /** A candidate is at most this long, like a file passage. */
@@ -44,6 +49,8 @@ export const DATA_FACTS_LIMITS = {
   /** What the meeting assistant is given: at most this many characters of Tableau text. */
   askChars: 3_500,
   askSourceRowsPerIndustry: 6,
+  /** A source-alone cue (no group named) lists this many industries, largest by leads. */
+  cueSourceRows: 2,
   /** A typed question longer than this is probably pasted text (see askUserWords). */
   askQuestionChars: 300,
 } as const
@@ -74,7 +81,19 @@ export interface DataGroup {
   coverage?: { have: number; of: number }
   stages: Partial<Record<DataStageKey, DataStage>>
 }
-export interface DataSourceRow { industry: string; source: string; bucket: string; leads: number; opps: number; customers: number }
+/** The stages a lead source has an actual for (Tableau's source budget file carries no per-source SQLs or demos). */
+export const SOURCE_STAGES = ['leads', 'opps', 'customers'] as const
+export type SourceStageKey = typeof SOURCE_STAGES[number]
+export interface DataSourceStage { actual: number; budget: number | null; pctToGoal: number | null }
+/** Tableau budgets per BUDGET LINE, not per lead source, and one line can count several sources (Paid Social sits inside "Paid Search -
+ *  Non-Brand"). So a line's actual and budget are the whole line's, never one source's. Optional: older files have none. */
+export interface DataBudgetLine { industry: string; line: string; sources: string[]; stages: Partial<Record<SourceStageKey, DataSourceStage>> }
+export interface DataSourceRow {
+  industry: string; source: string; bucket: string; leads: number; opps: number; customers: number
+  /** The budget line the writer verified this source counts under; absent in older files. Informational: the readers join a source to
+   *  its line by the line's own member list (budgetLinesFor), for the sources that have rows. */
+  budgetLine?: string
+}
 export interface DataFacts {
   label: string
   scope: string
@@ -85,6 +104,8 @@ export interface DataFacts {
   completeThrough?: string
   groups: DataGroup[]
   sources: DataSourceRow[]
+  /** Empty for a file written before budget lines. */
+  budgetLines: DataBudgetLine[]
 }
 
 export type DataFactsOff = 'missing' | 'unreadable' | 'invalid' | 'stale' | 'future'
@@ -118,6 +139,26 @@ function parseStage(raw: unknown): DataStage | null {
   return stage
 }
 
+function parseSourceStage(raw: unknown): DataSourceStage | null {
+  if (!isObj(raw)) return null
+  const actual = fin(raw.actual)
+  return actual === null || actual < 0 ? null : { actual, budget: fin(raw.budget), pctToGoal: fin(raw.pctToGoal) }
+}
+
+function parseBudgetLine(raw: unknown): DataBudgetLine | null {
+  if (!isObj(raw) || !isObj(raw.stages)) return null
+  const industry = str(raw.industry, 40), line = str(raw.line, 80)
+  if (!industry || !line) return null
+  const stages: DataBudgetLine['stages'] = {}
+  for (const key of SOURCE_STAGES) {
+    const st = parseSourceStage((raw.stages as Record<string, unknown>)[key])
+    if (st) stages[key] = st
+  }
+  if (!Object.keys(stages).length) return null
+  const sources = Array.isArray(raw.sources) ? raw.sources.map(x => str(x, 80)).filter((x): x is string => x !== null).slice(0, 20) : []
+  return { industry, line, sources, stages }
+}
+
 function parseGroup(raw: unknown): DataGroup | null {
   if (!isObj(raw)) return null
   const name = str(raw.name, 40)
@@ -154,14 +195,16 @@ export function parseDataFacts(raw: unknown, nowMs: number): DataFactsRead {
     if (!isObj(r)) continue
     const industry = str(r.industry, 40), source = str(r.source, 80)
     const leads = fin(r.leads), opps = fin(r.opps), customers = fin(r.customers)
-    if (industry && source && leads !== null && opps !== null && customers !== null) sources.push({ industry, source, bucket: typeof r.bucket === 'string' ? r.bucket : '', leads, opps, customers })
+    const budgetLine = str(r.budgetLine, 80)
+    if (industry && source && leads !== null && opps !== null && customers !== null) sources.push({ industry, source, bucket: typeof r.bucket === 'string' ? r.bucket : '', leads, opps, customers, ...(budgetLine ? { budgetLine } : {}) })
   }
+  const budgetLines = (Array.isArray(raw.budgetLines) ? raw.budgetLines.slice(0, DATA_FACTS_LIMITS.maxBudgetLines) : []).map(parseBudgetLine).filter((l): l is DataBudgetLine => l !== null)
   if (asOf - nowMs > DATA_FACTS_LIMITS.maxFutureMs) return { ok: false, reason: 'future' }
   const maxAgeMs = period.closed === true ? DATA_FACTS_LIMITS.maxClosedAgeDays * 24 * 3_600_000 : DATA_FACTS_LIMITS.maxAgeHours * 3_600_000
   if (nowMs - asOf > maxAgeMs) return { ok: false, reason: 'stale' }
   const through = typeof raw.completeThrough === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(raw.completeThrough) ? raw.completeThrough : undefined
   return { ok: true, facts: { label, scope, period: { label: pLabel, start: pStart, end: pEnd, closed: period.closed }, asOfIso: asOfIso as string, asOf,
-    ...(through ? { completeThrough: through } : {}), groups, sources } }
+    ...(through ? { completeThrough: through } : {}), groups, sources, budgetLines } }
 }
 
 /** Reads and parses the file. Missing, too big, unreadable or not JSON are three different reasons; never throws. */
@@ -237,40 +280,169 @@ function occurrences(tokens: string[], phrase: string[]): number[] {
   return at
 }
 
-function weakAt(tokens: string[], i: number): boolean {
-  const near = (k: number) => (k >= 0 && k < tokens.length ? tokens[k] : '')
-  const funnelOrIndustry = (t: string) => FUNNEL_TOKENS.has(t) || INDUSTRY_TOKENS.has(t)
-  if (funnelOrIndustry(near(i - 1)) || funnelOrIndustry(near(i + 1))) return true
-  return (BRIDGE_TOKENS.has(near(i - 1)) && FUNNEL_TOKENS.has(near(i - 2))) || (BRIDGE_TOKENS.has(near(i + 1)) && FUNNEL_TOKENS.has(near(i + 2)))
+/** `anchors` are the token positions of a lead-source name that is specific enough to stand alone (ppc, paid search): directly beside one,
+ *  a weak alias counts the way it does beside a funnel word ("paid search pet", "pet ppc"). Not across a bridge word: "let's dive in,
+ *  google ads are the topic" is not about the dive industry. */
+function weakAt(tokens: string[], i: number, anchors: ReadonlySet<number>): boolean {
+  const inside = (k: number) => k >= 0 && k < tokens.length
+  const funnel = (k: number) => inside(k) && FUNNEL_TOKENS.has(tokens[k])
+  const funnelOrIndustry = (k: number) => funnel(k) || anchors.has(k) || (inside(k) && INDUSTRY_TOKENS.has(tokens[k]))
+  const bridge = (k: number) => inside(k) && BRIDGE_TOKENS.has(tokens[k])
+  if (funnelOrIndustry(i - 1) || funnelOrIndustry(i + 1)) return true
+  return (bridge(i - 1) && funnel(i - 2)) || (bridge(i + 1) && funnel(i + 2))
+}
+
+// ── Lead sources ─────────────────────────────────────────────────────────────
+
+/** How a lead source is said aloud. `strong` aliases are jargon or multi-word names that stand alone; `weak` ones are plain English
+ *  (direct, events, email, organic, social...) and count only beside a named group or a stage word. `match` picks the source names IN THE
+ *  FILE the concept covers, so a file without Webinar rows has nothing for "webinar". Names in the file are aliases too (see sourceHits); where
+ *  a concept lists the same phrase as weak, the concept wins the tie, so a plain-English name stays weak. */
+interface SourceConcept { label: string; strong: string[]; weak: string[]; match: (key: string) => boolean; /** "non-brand" or "brand" right beside it narrows it. */ narrow?: boolean }
+const SOURCE_CONCEPTS: SourceConcept[] = [
+  { label: 'Paid Search', strong: ['paid search', 'ppc', 'pay per click', 'sem', 'search engine marketing', 'google ads', 'google adwords', 'adwords', 'search ads'], weak: [], match: k => k.startsWith('paid search'), narrow: true },
+  { label: 'Paid Search Brand', strong: [], weak: ['brand search', 'branded search'], match: k => k === 'paid search brand' },
+  { label: 'Paid Search Non-Brand', strong: [], weak: ['non brand search', 'nonbrand search'], match: k => k === 'paid search non brand' },
+  { label: 'Paid Social', strong: ['paid social', 'social ads', 'facebook ads', 'meta ads', 'instagram ads', 'linkedin ads', 'paid facebook', 'paid linkedin'], weak: ['facebook', 'linkedin', 'instagram'], match: k => k === 'paid social' },
+  { label: 'Social Media', strong: [], weak: ['social media'], match: k => k === 'social media' },
+  { label: 'Social', strong: [], weak: ['social'], match: k => k.includes('social') },
+  { label: 'Events', strong: ['trade show', 'trade shows', 'tradeshow', 'tradeshows'], weak: ['events', 'event', 'conference', 'conferences'], match: k => /(^| )events?( |$)/.test(k) },
+  { label: 'Organic', strong: [], weak: ['organic', 'organic search', 'seo'], match: k => k.startsWith('organic') },
+  { label: 'Direct', strong: [], weak: ['direct', 'direct traffic'], match: k => k === 'direct' },
+  { label: 'Referral Traffic', strong: [], weak: ['referral traffic'], match: k => k === 'referral traffic' },
+  { label: 'Customer Referral', strong: [], weak: ['customer referral', 'customer referrals'], match: k => k === 'customer referral' },
+  { label: 'Referral', strong: [], weak: ['referral', 'referrals'], match: k => k === 'referral traffic' || k === 'customer referral' },
+  { label: 'AI Referrals', strong: ['ai referrals', 'ai referral', 'ai traffic'], weak: ['chatgpt', 'chat gpt', 'perplexity'], match: k => k === 'ai referrals' },
+  { label: 'Aggregators', strong: ['paid aggregator', 'paid aggregators', 'lead aggregator', 'lead aggregators', 'capterra', 'software advice', 'getapp', 'g2 crowd'], weak: ['aggregator', 'aggregators'], match: k => k === 'paid aggregator' },
+  { label: 'Email', strong: ['email database', 'email marketing', 'newsletter', 'newsletters'], weak: ['email', 'emails'], match: k => k === 'email database' },
+  { label: 'Webinar', strong: [], weak: ['webinar', 'webinars'], match: k => k === 'webinar' },
+  { label: 'Partnership', strong: ['paid partnership', 'paid partnerships'], weak: ['partnership', 'partnerships'], match: k => k === 'paid partnership' },
+]
+
+const sourceKey = (name: string): string => wordsOfSpeech(name).join(' ')
+/** "Paid Search - Non-Brand" as people say it: "Paid Search Non-Brand". */
+export const sourceLabel = (name: string): string => name.replace(/\s+-\s+/g, ' ')
+
+/** Every lead source the file knows: the rows' and the budget lines' members. */
+function sourceNamesOf(facts: DataFacts): string[] {
+  const out = new Set<string>()
+  for (const r of facts.sources) out.add(r.source)
+  for (const l of facts.budgetLines) for (const x of l.sources) out.add(x)
+  return [...out]
+}
+
+/** Plain words that are a lead source only some of the time. A hit is dropped where the next or previous word says it is something else:
+ *  "direct reports", "the conference call", "let me email Gina". Keyed by the alias as spoken. */
+const PLAIN_WORD_GUARDS: Record<string, (tokens: string[], start: number, end: number) => boolean> = {
+  direct: (t, _s, e) => ['report', 'reports', 'mail', 'message', 'messages', 'line', 'lines'].includes(t[e] ?? ''),
+  conference: (t, _s, e) => ['call', 'calls', 'room', 'rooms'].includes(t[e] ?? ''),
+  conferences: (t, _s, e) => ['call', 'calls', 'room', 'rooms'].includes(t[e] ?? ''),
+  // "email" the verb: after a helper or a pronoun ("let me email Gina", "I will email them") or before "about" or a pronoun.
+  email: (t, s, e) => emailAsVerb(t, s, e),
+  emails: (t, s, e) => emailAsVerb(t, s, e),
+}
+const EMAIL_VERB_BEFORE = new Set(['to', 'will', 'll', 'should', 'please', 'can', 'could', 'would', 'just', 'gonna', 'may', 'might', 'must', 'me', 'us', 'we', 'i', 'you', 'they', 'he', 'she'])
+const EMAIL_VERB_AFTER = new Set(['about', 'him', 'her', 'them', 'me', 'us', 'you', 'everyone', 'everybody'])
+function emailAsVerb(t: string[], start: number, end: number): boolean {
+  return EMAIL_VERB_BEFORE.has(t[start - 1] ?? '') || EMAIL_VERB_AFTER.has(t[end] ?? '')
+}
+
+interface SourceHit { start: number; end: number; names: string[]; strong: boolean; label: string }
+
+/** "ppc non-brand", "brand ppc", "paid search brand": the word right beside a broad paid-search name picks Non-Brand or Brand. */
+function narrowedNames(tokens: string[], start: number, end: number, names: string[]): string[] {
+  const at = (k: number) => tokens[k] ?? ''
+  const nonBrand = (at(start - 2) === 'non' && at(start - 1) === 'brand') || at(start - 1) === 'nonbrand' || (at(end) === 'non' && at(end + 1) === 'brand') || at(end) === 'nonbrand'
+  if (nonBrand) return names.filter(n => sourceKey(n).includes('non brand'))
+  const brand = at(start - 1) === 'brand' || at(start - 1) === 'branded' || at(end) === 'brand' || at(end) === 'branded'
+  return brand ? names.filter(n => sourceKey(n).endsWith('brand') && !sourceKey(n).includes('non brand')) : names
+}
+
+/** Every place the speech names a lead source, the longer name winning where two overlap ("paid search non-brand" beats "paid search"). */
+function sourceHits(facts: DataFacts, tokens: string[]): SourceHit[] {
+  const all = sourceNamesOf(facts)
+  const hits: SourceHit[] = []
+  const add = (alias: string, strong: boolean, label: string, names: string[], narrow: boolean) => {
+    const phrase = wordsOfSpeech(alias)
+    const guard = phrase.length === 1 ? PLAIN_WORD_GUARDS[phrase[0]] : undefined
+    for (const start of occurrences(tokens, phrase)) {
+      const end = start + phrase.length
+      if (guard?.(tokens, start, end)) continue
+      hits.push({ start, end, names: narrow ? narrowedNames(tokens, start, end, names) : names, strong, label })
+    }
+  }
+  for (const c of SOURCE_CONCEPTS) {
+    const names = all.filter(n => c.match(sourceKey(n)))
+    for (const a of c.strong) add(a, true, c.label, names, !!c.narrow)
+    for (const a of c.weak) add(a, false, c.label, names, !!c.narrow)
+  }
+  for (const n of all) add(n, wordsOfSpeech(n).length > 1, sourceLabel(n), [n], false)
+  const span = (h: SourceHit) => h.end - h.start
+  return hits.filter((h, i) => !hits.some((o, j) => j !== i && o.start <= h.start && o.end >= h.end
+    && (span(o) > span(h) || (span(o) === span(h) && (o.names.length > h.names.length || (o.names.length === h.names.length && j < i))))))
+}
+
+export interface NamedSource {
+  /** What the speech called it ("Paid Search", "Events"), for a sentence. */
+  label: string
+  /** The source names in the file it covers. Empty when this extract has nothing for it. */
+  names: string[]
+  /** Specific enough to stand alone; a weak one is plain English and counts only beside a group or a stage word. */
+  strong: boolean
+  at: number
+}
+
+/** The lead sources the speech names, the one named last first. Two phrases that cover the same source names are one source. */
+export function namedSources(facts: DataFacts, speech: string): NamedSource[] {
+  const merged = new Map<string, NamedSource>()
+  for (const h of sourceHits(facts, wordsOfSpeech(speech))) {
+    const key = [...h.names].sort().join('|') || `none:${h.label}`
+    const cur = merged.get(key)
+    if (!cur) merged.set(key, { label: h.label, names: h.names, strong: h.strong, at: h.start })
+    else { cur.strong = cur.strong || h.strong; cur.at = Math.max(cur.at, h.start) }
+  }
+  return [...merged.values()].sort((a, b) => b.at - a.at)
 }
 
 export interface NamedGroup { group: DataGroup; at: number; /** Named by a Quilt brand name or sbu/xbu, not only by an industry word. */ brand: boolean }
 /** The groups the speech names, the one named last first. A group named twice counts at its last mention. */
 export function namedGroups(facts: DataFacts, speech: string): NamedGroup[] {
   const tokens = wordsOfSpeech(speech)
+  const anchors = new Set<number>()
+  for (const h of sourceHits(facts, tokens)) if (h.strong) for (let k = h.start; k < h.end; k += 1) anchors.add(k)
   const out: NamedGroup[] = []
   for (const group of facts.groups) {
     let last = -1, brand = false
     for (const alias of group.aliases) for (const i of occurrences(tokens, wordsOfSpeech(alias))) last = Math.max(last, i)
     for (const alias of group.brandAliases) for (const i of occurrences(tokens, wordsOfSpeech(alias))) { last = Math.max(last, i); brand = true }
-    for (const alias of group.weakAliases) for (const i of occurrences(tokens, wordsOfSpeech(alias))) if (weakAt(tokens, i)) last = Math.max(last, i)
+    for (const alias of group.weakAliases) for (const i of occurrences(tokens, wordsOfSpeech(alias))) if (weakAt(tokens, i, anchors)) last = Math.max(last, i)
     if (last >= 0) out.push({ group, at: last, brand })
   }
   return out.sort((a, b) => b.at - a.at)
 }
 
-export type DataTrigger = { fired: true; groups: DataGroup[]; stages: DataStageKey[]; brand: boolean } | { fired: false; why: 'no_group' | 'no_funnel' }
+export type DataTrigger = { fired: true; groups: DataGroup[]; stages: DataStageKey[]; brand: boolean
+  /** The lead source the speech named last, when the note should be about that source. Null: the group totals. */
+  source: NamedSource | null
+  /** The speech carries a funnel word or a figure. False only when a source beside a group fired it. */
+  funnel: boolean } | { fired: false; why: 'no_group' | 'no_funnel' }
 
-/** Fires when the speech names a group AND carries a funnel word or a figure (two digits or more, or a percent). */
+/** Fires when the speech names a group AND carries a funnel word or a figure (two digits or more, or a percent). A lead source narrows
+ *  the note: a specific one fires beside a group with no funnel word ("PPC landing pages for thrift") and, with a funnel word or a
+ *  figure, alone; a plain-English one ("events", "direct") counts only beside a group. */
 export function dataTrigger(facts: DataFacts, window: string): DataTrigger {
   const speech = recentSpeech(window)
   const named = namedGroups(facts, speech)
-  if (!named.length) return { fired: false, why: 'no_group' }
   const tokens = wordsOfSpeech(speech)
-  if (!tokens.some(t => FUNNEL_TOKENS.has(t)) && !hasFigure(speech)) return { fired: false, why: 'no_funnel' }
+  // The last specific source named; a plain-English one only when no specific one was, and only beside a group.
+  const usable = namedSources(facts, speech).filter(s => s.names.length > 0 && (s.strong || named.length > 0))
+  const source = usable.find(s => s.strong) ?? usable[0] ?? null
+  if (!named.length && !source) return { fired: false, why: 'no_group' }
+  const funnel = tokens.some(t => FUNNEL_TOKENS.has(t)) || hasFigure(speech)
+  if (!funnel && !(source?.strong && named.length)) return { fired: false, why: 'no_funnel' }
   const stages = [...new Set(tokens.map(t => STAGE_OF[t]).filter((s): s is DataStageKey => !!s))]
   const picked = named.slice(0, DATA_FACTS_LIMITS.maxNamedGroups)
-  return { fired: true, groups: picked.map(n => n.group), stages: DATA_STAGES.filter(s => stages.includes(s)), brand: picked.some(n => n.brand) }
+  return { fired: true, groups: picked.map(n => n.group), stages: DATA_STAGES.filter(s => stages.includes(s)), brand: picked.some(n => n.brand), source, funnel }
 }
 
 export interface DataGateInput {
@@ -319,7 +491,7 @@ export function quiltTitleSignal(facts: DataFacts, titles: ReadonlyArray<string
 
 const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
 const fmt = (n: number) => (Number.isInteger(n) ? String(n) : String(Math.round(n * 10) / 10))
-const pctText = (s: DataStage) => (s.pctToGoal === null ? '' : ` (${Math.round(s.pctToGoal)}%)`)
+const pctText = (s: { pctToGoal: number | null }) => (s.pctToGoal === null ? '' : ` (${Math.round(s.pctToGoal)}%)`)
 
 /** "Nov 2 05:41 CT": the refresh as the file states it, with CT only for a Central offset. */
 export function refreshText(iso: string): string {
@@ -375,14 +547,91 @@ export function dataCandidateText(facts: DataFacts, groups: DataGroup[], named:
   return build(groups.slice(0, 1), 2).slice(0, max)
 }
 
+const bySourceLeads = (a: DataSourceRow, b: DataSourceRow) => b.leads - a.leads
+const rowStages = (r: DataSourceRow, shown: SourceStageKey[]) => shown.map(k => `${k} ${fmt(r[k])}`).join(', ')
+
+/** The rows of the named source names, for these industries (every industry when null), the largest by leads first. */
+function sourceRowsFor(facts: DataFacts, names: string[], industries: string[] | null): DataSourceRow[] {
+  return facts.sources.filter(r => names.includes(r.source) && (!industries || industries.includes(r.industry))).sort(bySourceLeads)
+}
+
+/** The budget lines of an industry that count any of these sources. A line is the whole line's actual against its budget. */
+function budgetLinesFor(facts: DataFacts, industry: string, names: string[]): DataBudgetLine[] {
+  return facts.budgetLines.filter(l => l.industry === industry && l.sources.some(x => names.includes(x)))
+}
+
+/** One budget line as a sentence. `rowSources` are the sources shown above it (the ones that have rows). A line named for one of them
+ *  says what else it counts ("Budget line Paid Search Non-Brand (also counts Paid Social): ..."); a line named for something else says
+ *  the source sits inside it ("Paid Social is budgeted inside the Paid Search Non-Brand line, which also counts Paid Search Non-Brand: ...").
+ *  "Also counts" lists only other sources that have volume in this industry. Empty when the line has none of the shown stages. */
+function budgetClause(facts: DataFacts, l: DataBudgetLine, rowSources: string[], shown: SourceStageKey[]): string {
+  const text = lineStagesText(l, shown)
+  if (!text) return ''
+  const others = l.sources.filter(x => !rowSources.includes(x) && facts.sources.some(r => r.industry === l.industry && r.source === x && r.leads + r.opps + r.customers > 0))
+    .slice(0, 3).map(sourceLabel).join(', ')
+  const line = sourceLabel(l.line)
+  if (rowSources.some(x => sourceKey(x) === sourceKey(l.line))) return `Budget line ${line}${others ? ` (also counts ${others})` : ''}: ${text}.`
+  const mine = rowSources.filter(x => l.sources.includes(x)).map(sourceLabel)
+  return `${mine.join(' and ')} ${mine.length > 1 ? 'are' : 'is'} budgeted inside the ${line} line${others ? `, which also counts ${others}` : ''}: ${text}.`
+}
+
+function lineStagesText(l: DataBudgetLine, shown: SourceStageKey[]): string {
+  const parts = shown.filter(k => l.stages[k]).map(k => { const st = l.stages[k] as DataSourceStage; return `${k} ${fmt(st.actual)} vs ${st.budget === null ? 'no budget' : fmt(st.budget)}${pctText(st)}` })
+  return parts.join(', ')
+}
+
+/** The candidate when the room named a lead source. Leads with that source's own rows ("Thrift, Paid Search Non-Brand alone: leads 45,
+ *  opps 11, customers 3") for the named industry, or for the largest industries when no group is named; with the budget line it is counted
+ *  under, when the file has one, because Tableau budgets per line and a line can count more than one source. At most candidateChars:
+ *  budget lines, then a second group, then stages are dropped before it is cut. Empty when the source has no row for the named group. */
+export function dataSourceCandidateText(facts: DataFacts, source: NamedSource, groups: DataGroup[], named: DataStageKey[]): string {
+  const head = `Tableau ${periodText(facts)}, marketing-sourced, lead-source detail, refreshed ${refreshText(facts.asOfIso)}.`
+  const max = DATA_FACTS_LIMITS.candidateChars
+  const wanted = SOURCE_STAGES.filter(k => named.includes(k))
+  const all: SourceStageKey[] = wanted.length ? wanted : [...SOURCE_STAGES]
+  const several = source.names.length > 1
+  // `budget`: every row's line, only the largest row's line, or none.
+  type Budget = 'all' | 'top' | 'none'
+  const segment = (g: DataGroup | null, shown: SourceStageKey[], budget: Budget): string => {
+    if (g && g.kind === 'industry' && g.members.length === 1) {
+      const industry = g.members[0]
+      const rows = sourceRowsFor(facts, source.names, [industry])
+      if (!rows.length) return ''
+      let out = `${g.display ?? g.name}, ${rows.map(r => `${sourceLabel(r.source)} alone: ${rowStages(r, shown)}`).join('; ')}.`
+      if (budget !== 'none') for (const l of budgetLinesFor(facts, industry, (budget === 'top' ? rows.slice(0, 1) : rows).map(r => r.source))) {
+        const clause = budgetClause(facts, l, rows.map(r => r.source), shown)
+        if (clause) out += ` ${clause}`
+      }
+      return out
+    }
+    const found = sourceRowsFor(facts, source.names, g ? g.members : null)
+    // A list of the largest industries is only worth a cue when the largest has something to say.
+    if (!found.length || found[0].leads === 0) return ''
+    const rows = found.slice(0, DATA_FACTS_LIMITS.cueSourceRows)
+    return `${g ? `${g.display ?? g.name} industries, ` : ''}${several ? source.label : sourceLabel(source.names[0])} alone, largest by leads: ${rows.map(r => `${r.industry}${several ? ` ${sourceLabel(r.source)}` : ''} ${rowStages(r, shown)}`).join('; ')}.`
+  }
+  const tries = groups.length ? [groups, groups.slice(0, 1)] : [[] as DataGroup[]]
+  for (const gs of tries) for (const budget of ['all', 'top', 'none'] as Budget[]) for (let cut = 0; cut < 3; cut += 1) {
+    const shown = all.slice(0, Math.max(1, all.length - cut))
+    const parts = (gs.length ? gs : [null]).map(g => segment(g, shown, budget)).filter(Boolean)
+    const text = parts.length ? `${head} ${parts.join(' ')}` : ''
+    if (text && text.length <= max) return text
+  }
+  const parts = (tries[tries.length - 1].length ? tries[tries.length - 1] : [null]).map(g => segment(g, all.slice(0, 1), 'none')).filter(Boolean)
+  return parts.length ? `${head} ${parts.join(' ')}`.slice(0, max) : ''
+}
+
 /** The grounded candidate for a window, or why there is none. */
-export function dataCandidate(facts: DataFacts, window: string, nowDate: string): { candidate: GroundedNote; brand: boolean } | { none: 'no_group' | 'no_funnel' | 'no_stage' } {
+export function dataCandidate(facts: DataFacts, window: string, nowDate: string): { candidate: GroundedNote; brand: boolean; /** Fired by a lead source with no group named. */ sourceOnly: boolean } | { none: 'no_group' | 'no_funnel' | 'no_stage' } {
   const t = dataTrigger(facts, window)
   if (!t.fired) return { none: t.why }
-  const notes = dataCandidateText(facts, t.groups, t.stages)
+  const fromSource = t.source ? dataSourceCandidateText(facts, t.source, t.groups, t.stages) : ''
+  // A source with no row for the named group must not turn a window with no funnel word into a totals cue.
+  if (!fromSource && t.source && !t.funnel) return { none: 'no_funnel' }
+  const notes = fromSource || (t.groups.length ? dataCandidateText(facts, t.groups, t.stages) : '')
   if (!notes) return { none: 'no_stage' }
   const date = /^\d{4}-\d{2}-\d{2}/.exec(facts.asOfIso)?.[0] ?? nowDate
-  return { candidate: { id: 'D1', date, title: facts.label, notes, key: `data:tableau|${facts.label}|${facts.asOfIso}`, arm: 'data', kind: 'data' }, brand: t.brand }
+  return { candidate: { id: 'D1', date, title: facts.label, notes, key: `data:tableau|${facts.label}|${facts.asOfIso}`, arm: 'data', kind: 'data' }, brand: t.brand, sourceOnly: t.groups.length === 0 }
 }
 
 /** Appended to the writer's rules only when a Tableau note was kept. The v3/v4 rules themselves stay byte-identical. */
@@ -391,6 +640,8 @@ export const DATA_WRITER_ADDENDUM = '\nTableau note. A memory note whose title s
   + 'If you use it, say Tableau, the period, and marketing sources. Quote its numbers exactly; do not sum, project or round them. '
   + 'Set a figure the room said beside the Tableau figure only when both measure the same thing (same stage, same group). '
   + 'When they differ in scope, such as MRR or locations against marketing-sourced customers, say they are different measures and give the Tableau figure as context, not as proof that the room is wrong. '
+  + 'A note that names a lead source (Paid Search Non-Brand, Events...) covers only that source: say which source, never present it as the whole group, '
+  + 'and when it gives a budget line, say the budget is for that line, which can count other sources too. '
   + 'If the note does not cover what the room said, ignore it.'
 
 // ── The meeting assistant ────────────────────────────────────────────────────
@@ -407,23 +658,47 @@ export function askUserWords(question: string): string {
   return last.length <= DATA_FACTS_LIMITS.askQuestionChars && last.length < question.trim().length ? last : ''
 }
 
+/** A funnel stage or pacing word: enough, beside a plain-English source word, to say the question is about the data ("leads from events"). */
+const ASK_STAGE = /\b(?:leads?|opps?|opportunit(?:y|ies)|sqls?|demos?|logos?|customers?|pac(?:e|ing)|attainment)\b/i
+const ASK_SOURCE_WORD = /\b(?:sources?|channels?|campaigns?)\b/i
+/** "how did events do for thrift": a question about how something performed, which a group and a plain source word then make a data question. */
+const ASK_PERFORMANCE = /\b(?:do|doing|perform(?:ed|ing|ance)?|results?|numbers?|convert(?:ed|ing)?|conversions?|roi)\b/i
+
+/** The lead sources a typed question names that it may be answered from. A specific name ("paid search", "PPC") always counts; a
+ *  plain-English one ("direct", "events", "email") only with a stage or source word, or with a group beside "Tableau" or a
+ *  performance word, so "the direct reports on the thrift team" stays quiet. */
+export function askSources(facts: DataFacts, own: string, hasGroup: boolean): NamedSource[] {
+  const weakOk = ASK_STAGE.test(own) || ASK_SOURCE_WORD.test(own) || (hasGroup && (ASK_PERFORMANCE.test(own) || ASK_TABLEAU.test(own)))
+  return namedSources(facts, own).filter(x => x.strong || weakOk)
+}
+
 export interface AskDataIntent { intent: 'tableau' | 'named' | null; /** A Quilt brand or sbu/xbu is named. */ brand: boolean }
 /** What a typed question asks of the data: `tableau` when it says Tableau, `named` when it names a group and asks about funnel,
- *  budget or pacing, else null. `tableau` may be answered in any meeting but a personal one. `named` goes through dataArmGate like
+ *  budget or pacing, or names a lead source (see askSources) beside a group or a funnel word, else null. `tableau` may be answered in any meeting but a personal one. `named` goes through dataArmGate like
  *  the cue arm: a Quilt meeting, or an unconfirmed one with a Quilt brand named or a Quilt term in the meeting's title. */
 export function askDataIntent(question: string, facts: DataFacts): AskDataIntent {
   const own = askUserWords(question)
   const named = namedGroups(facts, own)
   const brand = named.some(n => n.brand)
   if (ASK_TABLEAU.test(own)) return { intent: 'tableau', brand }
-  return { intent: ASK_FUNNEL.test(own) && named.length > 0 ? 'named' : null, brand }
+  if (ASK_FUNNEL.test(own) && named.length > 0) return { intent: 'named', brand }
+  // A lead source: a specific name needs a group or a funnel word beside it ("how did paid search do for thrift"); a plain-English one
+  // already passed askSources' own test.
+  const sources = askSources(facts, own, named.length > 0)
+  if (sources.length && (!sources.some(x => x.strong) || named.length > 0 || ASK_FUNNEL.test(own))) return { intent: 'named', brand }
+  return { intent: null, brand }
 }
 
 /** The Tableau text the meeting assistant reads as a local source, or null. Stage rows for the groups the question names (or the
- *  business units and every industry when it names none), then the lead-source rows of the named industries. */
+ *  business units and every industry when it names none), then the lead-source rows of the named industries. When the question names a
+ *  lead source ("paid search", "PPC"), the answer is about that source instead: its rows for the named industries, or for every industry
+ *  when none is named, each with the budget line Tableau counts it under. The rows are listed, never added up: the writer's rules say
+ *  not to sum, and a sum of rows is not a figure Tableau shows. */
 export function dataFactsForAsk(facts: DataFacts, rawQuestion: string): { title: string; text: string } | null {
-  const named = namedGroups(facts, askUserWords(rawQuestion)).map(n => n.group)
-  const chosen = named.length ? named : facts.groups
+  const own = askUserWords(rawQuestion)
+  const named = namedGroups(facts, own).map(n => n.group)
+  const sources = askSources(facts, own, named.length > 0)
+  const chosen = named.length || sources.length ? named : facts.groups
   const lines: string[] = [
     `Tableau marketing funnel, ${periodText(facts)}. Scope: ${facts.scope}; marketing-sourced leads, opportunities, SQLs, demos and customers only. Not company revenue, MRR, ARR or location counts.`,
     `Extract refreshed ${refreshText(facts.asOfIso)}.${facts.completeThrough ? ` Complete through ${facts.completeThrough}.` : ''} Each stage: actual vs budget to date (% to goal; PM = prior month same period; PY = last year same period).`,
@@ -438,16 +713,51 @@ export function dataFactsForAsk(facts: DataFacts, rawQuestion: string): { title:
     })
     lines.push(`${g.display ?? g.name}${cov}: ${stages.join('; ')}`)
   }
-  if (named.length) {
+  if (sources.length) {
+    lines.push(...sourceLinesForAsk(facts, sources, named, lines.join('\n').length))
+  } else if (named.length) {
     for (const g of named) {
       const rows = facts.sources.filter(r => g.members.includes(r.industry)).sort((a, b) => b.leads - a.leads).slice(0, DATA_FACTS_LIMITS.askSourceRowsPerIndustry * Math.max(1, g.members.length))
       if (rows.length) lines.push(`${g.display ?? g.name} lead sources (leads/opps/customers): ${rows.map(r => `${g.kind === 'bu' ? `${r.industry} ` : ''}${r.source} ${fmt(r.leads)}/${fmt(r.opps)}/${fmt(r.customers)}`).join('; ')}`)
     }
   }
   const text = lines.join('\n').slice(0, DATA_FACTS_LIMITS.askChars)
-  return chosen.length ? { title: facts.label, text } : null
+  return chosen.length || sources.length ? { title: facts.label, text } : null
+}
+
+/** The lines for a question about a lead source: what was asked, then one line per industry (largest leads first) with that source's
+ *  rows and the budget line(s) it is counted under. Industries that do not fit in askChars are named as left out, never half shown. */
+function sourceLinesForAsk(facts: DataFacts, sources: NamedSource[], groups: DataGroup[], used: number): string[] {
+  const names = [...new Set(sources.flatMap(x => x.names))]
+  const asked = sources.map(x => `${x.label}${x.names.length ? ` (${x.names.map(sourceLabel).join(', ')})` : ' (no rows in this Tableau extract)'}`).join('; ')
+  const out = [`Lead source asked about: ${asked}. Each row below is that source alone as leads/opps/customers. Tableau sets budgets per budget line, and one line can count several sources, `
+    + 'so a budget appears only against its whole line, never against one source. Rows are listed, not added up.']
+  if (!names.length) return out
+  const wanted = groups.length ? new Set(groups.flatMap(g => g.members)) : null
+  // The industries that have rows for the source; plus a named single industry with none, so the answer says so.
+  const industries = [...new Set([...facts.sources.filter(r => names.includes(r.source)).map(r => r.industry).filter(i => !wanted || wanted.has(i)),
+    ...groups.filter(g => g.kind === 'industry').flatMap(g => g.members)])]
+  const leadsOf = (i: string) => sourceRowsFor(facts, names, [i]).reduce((n, r) => n + r.leads, 0)
+  const blocks = industries.sort((a, b) => leadsOf(b) - leadsOf(a)).map(industry => {
+    const rows = sourceRowsFor(facts, names, [industry])
+    const display = facts.groups.find(g => g.kind === 'industry' && g.name === industry)?.display ?? industry
+    const rowText = rows.length ? rows.map(r => `${sourceLabel(r.source)} ${fmt(r.leads)}/${fmt(r.opps)}/${fmt(r.customers)}`).join('; ') : 'no rows for this source'
+    // Only the sources that have rows here choose the lines: "social" must not pull in a line whose only link is a source with no rows.
+    const rowSources = rows.map(r => r.source)
+    const budget = budgetLinesFor(facts, industry, rowSources).map(l => budgetClause(facts, l, rowSources, [...SOURCE_STAGES])).filter(Boolean)
+    return `${display} (leads/opps/customers): ${rowText}.${budget.length ? ` ${budget.join(' ')}` : ''}`
+  })
+  const room = DATA_FACTS_LIMITS.askChars - used - out[0].length - 80
+  let spent = 0, shown = 0
+  for (const b of blocks) {
+    if (spent + b.length + 1 > room) break
+    out.push(b); spent += b.length + 1; shown += 1
+  }
+  if (shown < blocks.length) out.push(`${blocks.length - shown} more industries are not shown (the smallest by leads).`)
+  return out
 }
 
 /** Added to the meeting assistant's rules only when its Tableau source is in the context. */
 export const DATA_ASK_ADDENDUM = ' A Tableau source covers the marketing-sourced funnel only: when you use it, say Tableau, its period and marketing sources, '
-  + 'and never present it as company revenue, MRR, ARR or location counts. Set a figure from the meeting beside it only when both measure the same thing; otherwise name the difference.'
+  + 'and never present it as company revenue, MRR, ARR or location counts. Set a figure from the meeting beside it only when both measure the same thing; otherwise name the difference. '
+  + 'A lead-source row covers only that source: say which source it is, and when you quote a budget, say it is the budget line, which can count other sources too.'

package/server/lib/live-cues-v2-settings.ts

@@ -28,7 +28,8 @@ export type LiveCuesV2SettingSource = 'env' | 'setting' | 'default'
 /** COS Control's live-cue spend limits (6.79.2). Bounds are inclusive; integer fields take whole numbers only. */
 export const LIVE_CUES_V2_LIMIT_BOUNDS = {
   gate: { min: 0.5, max: 0.95, default: 0.8, integer: false, env: 'COS_LIVE_CUES_V2_GATE' },
-  maxCuesPerMeeting: { min: 1, max: 25, default: 25, integer: true, env: 'COS_LIVE_CUES_V2_MAX_PER_MEETING' },
+  // 6.99.0: the ceiling is 50 (Miles 2026-11-03, longer meetings); the default stays 25. Everything that clamps or validates this reads `.max`.
+  maxCuesPerMeeting: { min: 1, max: 50, default: 25, integer: true, env: 'COS_LIVE_CUES_V2_MAX_PER_MEETING' },
   cooldownSeconds: { min: 20, max: 900, default: 45, integer: true, env: 'COS_LIVE_CUES_V2_COOLDOWN_S' },
   dailyWriterCalls: { min: 1, max: 500, default: 150, integer: true, env: 'COS_LIVE_CUES_V2_DAILY_WRITER_CALLS' },
 } as const

package/server/lib/live-cues-v2.ts

@@ -90,8 +90,10 @@ export const LIVE_CUES_V2_LIMITS = {
   staleMs: 30_000,
   windowWords: 400,
   windowChars: 2_200,
-  /** 25 a meeting (Miles 2026-10-19: 10 ran out 10 minutes into an HC call). Writer calls stay at twice the cue cap so
-   *  discarded drafts cannot end a meeting's cues early, and the weekly default keeps the same ~15 capped meetings. */
+  /** FALLBACK DEFAULTS ONLY (nothing reads these at run time): the live cap is `resolveLiveCuesV2Limits().maxCuesPerMeeting`, which
+   *  Settings can raise to 50 (6.99.0) and env can lock. 25 a meeting (Miles 2026-10-19: 10 ran out 10 minutes into an HC call).
+   *  Writer calls stay at twice the cue cap so discarded drafts cannot end a meeting's cues early. At 25 cues the weekly default
+   *  of 750 writer calls covers ~15 capped meetings (50 calls each); at 50 cues it covers ~7 (100 calls each). */
   maxCuesPerMeeting: 25,
   maxWriterCallsPerMeeting: 50,
   defaultWeeklyWriterCalls: 750,
@@ -171,9 +173,9 @@ export function resolveLiveCuesV2Limits(env: NodeJS.ProcessEnv = process.env, se
   try { saved = settings?.limits?.() ?? {} } catch { saved = {} }
   const fromEnv: Record<LiveCuesV2LimitName, number | null> = {
     gate: envGate(env),
-    maxCuesPerMeeting: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.env, 1, 25),
+    maxCuesPerMeeting: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.env, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.min, LIVE_CUES_V2_LIMIT_BOUNDS.maxCuesPerMeeting.max),
     cooldownSeconds: envCooldownSeconds(env),
-    dailyWriterCalls: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.env, 1, 500),
+    dailyWriterCalls: envWhole(env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.env, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.min, LIVE_CUES_V2_LIMIT_BOUNDS.dailyWriterCalls.max),
   }
   const out = {} as LiveCuesV2Limits
   for (const name of LIVE_CUES_V2_LIMIT_NAMES) {
@@ -1323,7 +1325,9 @@ export class LiveCuesV2Engine {
       if (!early.ok) { trace.dataArm = early.why; return null }
       const found = dataCandidate(read.facts, window, today)
       if ('none' in found) { trace.dataArm = found.none; return null }
-      const gate = dataArmGate({ domain: ctx.domain, orientationFailed: ctx.orientationFailed, brand: found.brand, memoryQuilt: ctx.memoryQuilt, titleQuilt: quiltTitleSignal(read.facts, ctx.titles) })
+      // A lead source alone (no group named) is everyday speech in a marketing agency's meeting ("the trade show is in 30 days"): a Quilt
+      // memory among the candidates does not vouch for it. Only a Quilt-confirmed meeting or a Quilt term in the title does.
+      const gate = dataArmGate({ domain: ctx.domain, orientationFailed: ctx.orientationFailed, brand: found.brand, memoryQuilt: found.sourceOnly ? false : ctx.memoryQuilt, titleQuilt: quiltTitleSignal(read.facts, ctx.titles) })
       if (!gate.ok) { trace.dataArm = gate.why; return null }
       trace.dataArm = 'offered'
       trace.dataSignal = gate.signal