fullstackgtm 0.31.0 → 0.33.0

package/src/cli.ts

@@ -41,6 +41,14 @@ import { auditReportToHtml, auditReportToMarkdown, type ReportOptions } from "./
 import { builtinAuditRules } from "./rules.ts";
 import { sampleSnapshot } from "./sampleData.ts";
 import { normalizeTranscript, parseCall, suggestCallDeal, type ExtractedCallInsight, type ParsedCall } from "./calls.ts";
+import {
+  classifyCall,
+  rubricForCallType,
+  rubricPresets,
+  CALL_TYPES,
+  CALL_TYPE_IDS,
+  type CallType,
+} from "./callTypes.ts";
 import {
   captureMarket,
   computeFrontStates,
@@ -67,6 +75,7 @@ import { buildWorksheet, classifyMarket } from "./marketClassify.ts";
 import { marketMapToHtml, marketMapToMarkdown } from "./marketReport.ts";
 import {
   DEFAULT_RUBRIC,
+  classifyCallLlm,
   detectProviderFromKey,
   extractInsightsLlm,
   parseRubric,
@@ -75,6 +84,7 @@ import {
   validateLlmKey,
   type CallScorecard,
   type LlmProvider,
+  type Rubric,
 } from "./llm.ts";
 import {
   buildEnrichPlan,
@@ -159,7 +169,8 @@ Usage:
   fullstackgtm diff --before <a.json> --after <b.json> [--json] [--fail-on-new-findings]
   fullstackgtm merge --input <a.json> --input <b.json> [...] --out <merged.json> [--json]
   fullstackgtm call parse --transcript <file> [--title t] [--source fathom|granola|...] [--model m] [--deterministic] [--json|--ndjson] [--out <path>]
-  fullstackgtm call score --transcript <file>|--call <parsed.json> [--rubric <rubric.json>] [--model m] [--json|--out <path>]
+  fullstackgtm call classify --transcript <file>|--call <parsed.json> [--llm] [--deterministic] [--json]
+  fullstackgtm call score --transcript <file>|--call <parsed.json> [--call-type <t>] [--rubric <rubric.json>] [--model m] [--json|--out <path>]
   fullstackgtm call link --attendees <a@x.com,...> | --domain <x.com>  [source options] [--json]
   fullstackgtm call plan --transcript <file>|--call <parsed.json> --deal <id> [source options] [--save|--json]
                                                calls become evidence: LLM extraction by default (bring your own
@@ -649,14 +660,20 @@ function parseValueOverrides(args: string[]) {
 async function callCommand(args: string[]) {
   const [subcommand, ...rest] = args;
   if (args.includes("--help") || args.includes("-h")) {
-    console.log(`call parse --transcript <file> [--title t] [--source s] [--model m] [--deterministic] [--json|--ndjson] [--out <path>]
-call score --transcript <file>|--call <parsed.json> [--rubric <rubric.json>] [--model m] [--json|--out <path>]
-call link --attendees <a@x.com,...> | --domain <x.com>  [source options] [--json]
-call plan --transcript <file>|--call <parsed.json> --deal <id> [source options] [--save|--json]
+    console.log(`call parse    --transcript <file> [--title t] [--source s] [--model m] [--deterministic] [--json|--ndjson] [--out <path>]
+call classify --transcript <file>|--call <parsed.json> [--llm] [--deterministic] [--json] [--list]
+call score    --transcript <file>|--call <parsed.json> [--call-type <t>] [--rubric <rubric.json>] [--model m] [--json|--out <path>] [--list-rubrics]
+call link     --attendees <a@x.com,...> | --domain <x.com>  [source options] [--json]
+call plan     --transcript <file>|--call <parsed.json> --deal <id> [source options] [--save|--json]
+
+classify picks the call type (deterministic signals; --llm for a model tiebreak).
+score auto-selects the type-specific rubric from that classification unless you
+pass --call-type or --rubric. Call types: ${CALL_TYPE_IDS.join(", ")}.
 
 parse/score default to LLM extraction (Anthropic or OpenAI key via env,
-\`login anthropic|openai\`, or a one-time prompt). parse --deterministic is
-the free keyword baseline; score always needs a key (scoring is LLM work).`);
+\`login anthropic|openai\`, or a one-time prompt). parse --deterministic is the
+free keyword baseline and classify --deterministic needs no key.
+score always needs a key (scoring is LLM work).`);
     return;
   }
 
@@ -692,6 +709,64 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
     });
   };
 
+  // Reconstruct plain transcript text from either a --transcript file (any
+  // dialect, normalized) or a parsed --call JSON. Shared by classify + score.
+  const loadTranscriptText = (): string => {
+    const transcriptPath = option(rest, "--transcript");
+    if (transcriptPath) {
+      return normalizeTranscript(readFileSync(resolve(process.cwd(), transcriptPath), "utf8"));
+    }
+    const callPath = option(rest, "--call");
+    if (!callPath) throw new Error(`call ${subcommand} requires --transcript <file> or --call <parsed.json>`);
+    const parsed = JSON.parse(readFileSync(resolve(process.cwd(), callPath), "utf8")) as ParsedCall;
+    return parsed.segments.map((s) => (s.speaker ? `${s.speaker}: ${s.text}` : s.text)).join("\n");
+  };
+
+  if (subcommand === "classify") {
+    if (rest.includes("--list")) {
+      const lines = CALL_TYPES.map((d) => `${d.id.padEnd(22)} ${d.name} — ${d.definition}`);
+      console.log(rest.includes("--json") ? JSON.stringify(CALL_TYPES, null, 2) : lines.join("\n"));
+      return;
+    }
+    const transcriptText = loadTranscriptText();
+    const title = option(rest, "--title") ?? undefined;
+    const deterministic = classifyCall(transcriptText);
+    // LLM tiebreak: explicit --llm, or auto when the deterministic pass is unsure
+    // and a key is available (never required — deterministic always answers).
+    const wantLlm = rest.includes("--llm") || (!rest.includes("--deterministic") && deterministic.confidence !== "high" && Boolean(resolveLlmCredential()));
+    let result: {
+      type: CallType;
+      confidence: string;
+      reason: string;
+      method: string;
+      candidates?: typeof deterministic.candidates;
+      model?: string;
+    } = deterministic;
+    if (wantLlm) {
+      const credential = await requireLlmCredential("score");
+      const llm = await classifyCallLlm(transcriptText, CALL_TYPES, {
+        ...credential,
+        model: option(rest, "--model") ?? undefined,
+        title,
+      });
+      result = { type: llm.type, confidence: "high", reason: llm.reason, method: "llm", model: llm.model };
+    }
+    if (rest.includes("--json")) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const def = CALL_TYPES.find((d) => d.id === result.type);
+    console.log(`Call type: ${def?.name ?? result.type} (${result.type})`);
+    console.log(`Confidence: ${result.confidence} · via ${result.method}${result.model ? ` (${result.model})` : ""}`);
+    console.log(`Why: ${result.reason}`);
+    if (result.method === "deterministic" && deterministic.candidates.length > 1) {
+      const others = deterministic.candidates.slice(1, 4).map((c) => `${c.type} (${c.score})`).join(", ");
+      console.log(`Other matches: ${others}`);
+    }
+    console.log(`\nScore it with this rubric: fullstackgtm call score ${option(rest, "--transcript") ? `--transcript ${option(rest, "--transcript")}` : `--call ${option(rest, "--call")}`} --call-type ${result.type}`);
+    return;
+  }
+
   if (subcommand === "parse") {
     const parsed = await loadParsedCall();
     const outPath = option(rest, "--out");
@@ -779,9 +854,13 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
   }
 
   if (subcommand === "score") {
-    // Rubric problems surface before any credential or API work.
+    if (rest.includes("--list-rubrics")) {
+      console.log(JSON.stringify(rubricPresets(), null, 2));
+      return;
+    }
+    // Explicit-rubric problems surface before any credential or API work.
     const rubricPath = option(rest, "--rubric");
-    let rubric = DEFAULT_RUBRIC;
+    let rubric: Rubric | undefined;
     if (rubricPath) {
       const rubricRaw = readFileSync(resolve(process.cwd(), rubricPath), "utf8");
       try {
@@ -792,6 +871,10 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
         );
       }
     }
+    const callTypeOpt = option(rest, "--call-type") as CallType | undefined;
+    if (callTypeOpt && !CALL_TYPE_IDS.includes(callTypeOpt)) {
+      throw new Error(`Unknown --call-type "${callTypeOpt}". One of: ${CALL_TYPE_IDS.join(", ")}.`);
+    }
     const credential = await requireLlmCredential("score");
     const transcriptPath = option(rest, "--transcript");
     let transcriptText: string;
@@ -807,6 +890,17 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
         .join("\n");
       title = title ?? parsed.title;
     }
+    // Rubric selection: explicit --rubric wins, then --call-type, else the
+    // deterministic classifier picks the type-specific preset. No generic
+    // discovery rubric silently applied to a renewal anymore.
+    if (!rubric) {
+      const type = callTypeOpt ?? classifyCall(transcriptText).type;
+      rubric = rubricForCallType(type, DEFAULT_RUBRIC);
+      if (!rest.includes("--json")) {
+        const how = callTypeOpt ? `--call-type ${callTypeOpt}` : `auto-classified as ${type}`;
+        console.error(`Scoring with the "${rubric.name ?? "Generic"}" rubric (${how}). Override with --rubric <file> or --call-type <type>.`);
+      }
+    }
     const scorecard = await scoreCallLlm(transcriptText, rubric, {
       ...credential,
       model: option(rest, "--model") ?? undefined,
@@ -822,7 +916,7 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
     return;
   }
 
-  throw new Error(`call supports: parse, link, plan, score (got ${subcommand ?? "nothing"})`);
+  throw new Error(`call supports: parse, classify, link, plan, score (got ${subcommand ?? "nothing"})`);
 }
 
 /**
@@ -862,10 +956,14 @@ async function requireLlmCredential(
 }
 
 function renderScorecard(scorecard: CallScorecard, title?: string): string {
+  const bandText = scorecard.band ? ` — ${scorecard.band.label}` : "";
+  const rubricLine = scorecard.rubricName ? `Rubric: ${scorecard.rubricName}${scorecard.callType ? ` (${scorecard.callType})` : ""}` : "";
   const lines = [
     `# Coaching Scorecard${title ? ` — ${title}` : ""}`,
     "",
-    `**Overall: ${scorecard.overallScore}/${scorecard.scale}** (model: ${scorecard.model})`,
+    `**Overall: ${scorecard.overallScore}/${scorecard.scale}${bandText}** (model: ${scorecard.model})`,
+    ...(scorecard.band?.meaning ? [`> ${scorecard.band.meaning}`] : []),
+    ...(rubricLine ? ["", `_${rubricLine}_`] : []),
     "",
     "| Dimension | Score | | Coaching note |",
     "| --- | --- | --- | --- |",

package/src/index.ts

@@ -179,6 +179,7 @@ export { sampleSnapshot } from "./sampleData.ts";
 export {
   DEFAULT_MODELS,
   DEFAULT_RUBRIC,
+  classifyCallLlm,
   detectProviderFromKey,
   extractInsightsLlm,
   forcedToolCall,
@@ -187,12 +188,27 @@ export {
   scoreCallLlm,
   validateLlmKey,
   type CallScorecard,
+  type LlmCallClassification,
   type LlmCredential,
   type LlmExtractedInsight,
   type LlmProvider,
   type Rubric,
+  type RubricDimension,
+  type ScoreBand,
   type ScoredDimension,
 } from "./llm.ts";
+export {
+  classifyCall,
+  rubricForCallType,
+  rubricPresets,
+  bandForScore,
+  CALL_TYPES,
+  CALL_TYPE_IDS,
+  BANDS_5,
+  type CallType,
+  type CallTypeDef,
+  type CallClassification,
+} from "./callTypes.ts";
 export { resolveRecord, type ResolveCandidate, type ResolveMatch, type ResolveResult } from "./resolve.ts";
 export {
   captureMarket,
@@ -275,6 +291,20 @@ export {
   type VendorScale,
 } from "./marketScale.ts";
 export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.ts";
+export {
+  registrableDomain,
+  categoryKeywords,
+  pickCategoryPage,
+  extractLogoUrl,
+  resolveFinalUrl,
+  detectDrift,
+  findCategoryPageInSitemap,
+  findCategoryPage,
+  fetchLogoDataUri,
+  type FetchText,
+  type FetchBytes,
+  type ResolveUrl,
+} from "./marketSourcing.ts";
 export {
   computeMissedFirings,
   createFileScheduleRunStore,

package/src/llm.ts

@@ -1,5 +1,6 @@
 import { getCredential } from "./credentials.ts";
 import type { CallInsightType, ExtractedCallInsight } from "./calls.ts";
+import { CALL_TYPE_IDS, type CallType } from "./callTypes.ts";
 
 /**
  * LLM-powered call extraction and scoring. Bring-your-own-key, two providers
@@ -170,13 +171,37 @@ function actionGroundedInEvidence(text: string, evidence: string): boolean {
 
 // ── Rubric scoring ─────────────────────────────────────────────────────────
 
+/** A qualitative band over the weighted overall (e.g. "developing" at >=2). */
+export type ScoreBand = { label: string; min: number; meaning?: string };
+
+export type RubricDimension = {
+  name: string;
+  weight: number;
+  rubric: string;
+  /** Anchored behavioral examples of a top score — sharpens the model and cuts variance. */
+  anchorsHigh?: string[];
+  /** Anchored behavioral examples of a bottom score. */
+  anchorsLow?: string[];
+  /** Verbatim phrases to listen for — tightens evidence grounding. */
+  evidenceCues?: string[];
+  /** Reflective questions surfaced to the rep alongside the score. */
+  coachingPrompts?: string[];
+};
+
 export type Rubric = {
   scale: number;
-  dimensions: Array<{ name: string; weight: number; rubric: string }>;
+  /** Display name (e.g. the call type this rubric is built for). */
+  name?: string;
+  /** The call type this rubric scores, when type-specific. */
+  callType?: CallType;
+  dimensions: RubricDimension[];
+  /** Optional qualitative bands over the weighted overall. */
+  bands?: ScoreBand[];
 };
 
 export const DEFAULT_RUBRIC: Rubric = {
   scale: 5,
+  name: "Generic",
   dimensions: [
     { name: "Depth of Discovery", weight: 1.2, rubric: "Did the rep uncover concrete pain, current process, and cost of inaction with specifics — 5 — or stay at surface level — 1?" },
     { name: "Next Steps & Commitment", weight: 1.2, rubric: "Did the call end with a specific, time-bound, mutually agreed next step (5) or vague intentions (1)?" },
@@ -200,6 +225,11 @@ export type CallScorecard = {
   /** Weighted average, computed deterministically client-side. */
   overallScore: number;
   scale: number;
+  /** Qualitative band for the overall, computed client-side from the rubric's bands. */
+  band?: ScoreBand;
+  /** The rubric used, for provenance in reports. */
+  rubricName?: string;
+  callType?: CallType;
   highlights: string[];
   missedItems: string[];
   model: string;
@@ -236,9 +266,16 @@ export async function scoreCallLlm(
   const model = options.model ?? DEFAULT_MODELS[options.provider];
   const text = truncateTranscript(transcript);
   const rubricText = rubric.dimensions
-    .map((d) => `- ${d.name} (weight ${d.weight}): ${d.rubric}`)
+    .map((d) => {
+      const lines = [`- ${d.name} (weight ${d.weight}): ${d.rubric}`];
+      if (d.anchorsHigh?.length) lines.push(`    a ${rubric.scale} looks like: ${d.anchorsHigh.join("; ")}`);
+      if (d.anchorsLow?.length) lines.push(`    a 1 looks like: ${d.anchorsLow.join("; ")}`);
+      if (d.evidenceCues?.length) lines.push(`    listen for: ${d.evidenceCues.join(", ")}`);
+      return lines.join("\n");
+    })
     .join("\n");
-  const prompt = `Score this sales call against the rubric. Score every dimension 1-${rubric.scale}. Ground every score in verbatim quotes; if the transcript gives no signal for a dimension, score it low and say why in the coaching note.\n\nRubric:\n${rubricText}\n\n${options.title ? `Call: ${options.title}\n` : ""}Transcript:\n${text}`;
+  const heading = rubric.name ? `${rubric.name} call` : "sales call";
+  const prompt = `Score this ${heading} against the rubric. Score every dimension 1-${rubric.scale}, calibrating to the anchored examples where given. Ground every score in verbatim quotes; if the transcript gives no signal for a dimension, score it low and say why in the coaching note.\n\nRubric:\n${rubricText}\n\n${options.title ? `Call: ${options.title}\n` : ""}Transcript:\n${text}`;
   const result = (await forcedToolCall(prompt, "score_call", SCORE_SCHEMA(rubric.scale, rubric.dimensions), model, options)) as {
     dimensions?: Array<{ name: string; score: number; evidence?: string[]; coaching_note?: string }>;
     highlights?: string[];
@@ -259,31 +296,91 @@ export async function scoreCallLlm(
   const totalWeight = dimensions.reduce((sum, d) => sum + d.weight, 0);
   const overallScore =
     Math.round((dimensions.reduce((sum, d) => sum + d.score * d.weight, 0) / totalWeight) * 100) / 100;
+  const band = rubric.bands?.length
+    ? [...rubric.bands].sort((a, b) => b.min - a.min).find((b) => overallScore >= b.min)
+    : undefined;
   return {
     dimensions,
     overallScore,
     scale: rubric.scale,
+    band,
+    rubricName: rubric.name,
+    callType: rubric.callType,
     highlights: result.highlights ?? [],
     missedItems: result.missed_items ?? [],
     model,
   };
 }
 
+const strArray = (value: unknown): string[] | undefined =>
+  Array.isArray(value) && value.length ? value.map((v) => String(v)) : undefined;
+
 export function parseRubric(json: string): Rubric {
   const parsed = JSON.parse(json) as Partial<Rubric>;
   if (!Array.isArray(parsed.dimensions) || parsed.dimensions.length === 0) {
     throw new Error("Rubric needs a dimensions array: { scale, dimensions: [{ name, weight, rubric }] }");
   }
+  const bands = Array.isArray(parsed.bands)
+    ? parsed.bands
+        .filter((b) => b && typeof b.min === "number" && b.label)
+        .map((b) => ({ label: String(b.label), min: Number(b.min), meaning: b.meaning ? String(b.meaning) : undefined }))
+    : undefined;
   return {
     scale: parsed.scale ?? 5,
+    name: parsed.name ? String(parsed.name) : undefined,
+    callType: parsed.callType,
+    bands: bands?.length ? bands : undefined,
     dimensions: parsed.dimensions.map((d) => ({
       name: String(d.name),
       weight: typeof d.weight === "number" ? d.weight : 1,
       rubric: String(d.rubric ?? ""),
+      anchorsHigh: strArray(d.anchorsHigh),
+      anchorsLow: strArray(d.anchorsLow),
+      evidenceCues: strArray(d.evidenceCues),
+      coachingPrompts: strArray(d.coachingPrompts),
     })),
   };
 }
 
+// ── Call-type classification (LLM tiebreak) ────────────────────────────────
+
+const CLASSIFY_SCHEMA = {
+  type: "object",
+  required: ["type", "reason"],
+  properties: {
+    type: { type: "string", enum: CALL_TYPE_IDS },
+    reason: { type: "string", description: "One sentence, citing what in the transcript decided it." },
+  },
+} as const;
+
+export type LlmCallClassification = { type: CallType; reason: string; model: string; method: "llm" };
+
+/**
+ * Model tiebreak for call-type classification — the opt-in counterpart to the
+ * deterministic `classifyCall`. Same forced-tool-call seam as every other LLM
+ * feature; returns the canonical CallType plus a one-line reason.
+ */
+export async function classifyCallLlm(
+  transcript: string,
+  defs: Array<{ id: string; name: string; definition: string }>,
+  options: LlmCallOptions & { title?: string },
+): Promise<LlmCallClassification> {
+  const model = options.model ?? DEFAULT_MODELS[options.provider];
+  const text = truncateTranscript(transcript);
+  const taxonomy = defs.map((d) => `- ${d.id} (${d.name}): ${d.definition}`).join("\n");
+  const prompt = `Classify this sales call into exactly one type from the taxonomy. Pick the single best fit; use "other" only if none apply.\n\nTaxonomy:\n${taxonomy}\n\n${options.title ? `Call: ${options.title}\n` : ""}Transcript:\n${text}`;
+  const result = (await forcedToolCall(prompt, "classify_call", CLASSIFY_SCHEMA, model, options)) as {
+    type?: CallType;
+    reason?: string;
+  };
+  return {
+    type: (result.type as CallType) ?? "other",
+    reason: result.reason ?? "Model did not give a reason.",
+    model,
+    method: "llm",
+  };
+}
+
 // ── Provider plumbing (raw fetch, forced tool calls) ───────────────────────
 
 /**

package/src/marketReport.ts

@@ -196,6 +196,7 @@ function svgScatter(
   anchor: string | undefined,
   colorByVendor: Map<string, string>,
   numberByVendor: Map<string, number>,
+  logoByVendor: Map<string, string | undefined>,
 ): string {
   const W = 640;
   const H = 480;
@@ -217,23 +218,45 @@ function svgScatter(
   // raises a bubble to the front (JS re-appends its <g>), so even a bubble
   // born fully underneath a bigger one is one mouse-over from visible.
   const ordered = [...points].sort((a, b) => b.size - a.size);
+  const clipDefs: string[] = [];
   const dots = ordered
-    .map((p) => {
+    .map((p, i) => {
       const r = p.noScale ? 7 : 7 + 24 * Math.sqrt(p.size);
       const color = colorByVendor.get(p.vendorId) ?? "#717171";
       const number = numberByVendor.get(p.vendorId) ?? 0;
-      const cx = sx(p.x).toFixed(1);
-      const cy = sy(p.y);
+      const cxN = sx(p.x);
+      const cyN = sy(p.y);
+      const cx = cxN.toFixed(1);
+      const cy = cyN.toFixed(1);
       const ring = p.vendorId === anchor ? ` stroke="#1c1c1c" stroke-width="2.5"` : ` stroke="#ffffff" stroke-width="1.5"`;
       // No measurable scale: minimal dashed outline — visibly "no data", never a guess.
       const fill = p.noScale ? ` fill="${color}" fill-opacity="0.2" stroke="${color}" stroke-width="1.5" stroke-dasharray="3 2"` : ` fill="${color}" fill-opacity="0.78"${ring}`;
+      const circle = `<circle cx="${cx}" cy="${cy}" r="${r.toFixed(1)}"${fill}/>`;
+
+      // When the vendor has a brand logo and the bubble is big enough to read
+      // it, the logo IS the in-bubble label: a white disc clipped to the
+      // circle carries it, a colored rim still ties the dot to its legend
+      // color, and the legend number moves just above so the cross-reference
+      // survives. Small or logo-less dots keep the numbered-bubble treatment.
+      const logo = logoByVendor.get(p.vendorId);
+      const hasLogo = !p.noScale && r >= 12 && typeof logo === "string" && logo.startsWith("data:image/");
+      if (hasLogo) {
+        const ri = r - Math.max(3, r * 0.14);
+        const clipId = `bclip-${i}`;
+        clipDefs.push(`<clipPath id="${clipId}"><circle cx="${cx}" cy="${cy}" r="${ri.toFixed(1)}"/></clipPath>`);
+        const disc = `<circle cx="${cx}" cy="${cy}" r="${ri.toFixed(1)}" fill="#ffffff" style="pointer-events:none"/>`;
+        const img = `<image href="${e(logo as string)}" x="${(cxN - ri).toFixed(1)}" y="${(cyN - ri).toFixed(1)}" width="${(2 * ri).toFixed(1)}" height="${(2 * ri).toFixed(1)}" preserveAspectRatio="xMidYMid meet" clip-path="url(#${clipId})" style="pointer-events:none"/>`;
+        const numberAbove = `<text x="${cx}" y="${(cyN - r - 3).toFixed(1)}" text-anchor="middle" font-size="10" font-weight="700" fill="${color}" style="pointer-events:none">${number}</text>`;
+        return `<g class="bubble" data-v="${e(p.vendorId)}">${circle}${disc}${img}${numberAbove}</g>`;
+      }
+
       // Numbers go inside when they fit, above the bubble when they don't.
       const fs = Math.max(10, Math.min(14, r * 0.9));
       const numberSvg =
         r >= 10 && !p.noScale
-          ? `<text x="${cx}" y="${(cy + fs * 0.36).toFixed(1)}" text-anchor="middle" font-size="${fs.toFixed(1)}" font-weight="700" fill="${numeralColor(color)}" style="pointer-events:none">${number}</text>`
-          : `<text x="${cx}" y="${(cy - r - 3).toFixed(1)}" text-anchor="middle" font-size="10" font-weight="700" fill="${color}" style="pointer-events:none">${number}</text>`;
-      return `<g class="bubble${p.noScale ? " no-scale" : ""}" data-v="${e(p.vendorId)}"><circle cx="${cx}" cy="${cy.toFixed(1)}" r="${r.toFixed(1)}"${fill}/>${numberSvg}</g>`;
+          ? `<text x="${cx}" y="${(cyN + fs * 0.36).toFixed(1)}" text-anchor="middle" font-size="${fs.toFixed(1)}" font-weight="700" fill="${numeralColor(color)}" style="pointer-events:none">${number}</text>`
+          : `<text x="${cx}" y="${(cyN - r - 3).toFixed(1)}" text-anchor="middle" font-size="10" font-weight="700" fill="${color}" style="pointer-events:none">${number}</text>`;
+      return `<g class="bubble${p.noScale ? " no-scale" : ""}" data-v="${e(p.vendorId)}">${circle}${numberSvg}</g>`;
     })
     .join("");
 
@@ -257,6 +280,7 @@ function svgScatter(
   const yNeg = ay.signed ? yLabel(wrapPole(ay.negativePole, 26), H - PAD_BOTTOM, "start") : "";
 
   return `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${e(ax.label)} vs ${e(ay.label)}">
+    ${clipDefs.length ? `<defs>${clipDefs.join("")}</defs>` : ""}
     <rect x="${PAD_X}" y="${PAD_TOP}" width="${W - 2 * PAD_X}" height="${H - PAD_TOP - PAD_BOTTOM}" class="plot"/>
     ${midX}${midY}
     ${xNeg}${xPos}
@@ -399,7 +423,7 @@ function axisSectionsHtml(
   <h2>Strategic map: ${e(axInfo.label)} &#215; ${e(ayInfo.label)}</h2>
   <figure class="map">
     <div class="map-row">
-      ${svgScatter(points, axInfo, ayInfo, config.anchorVendor, colorByVendor, numberByVendor)}
+      ${svgScatter(points, axInfo, ayInfo, config.anchorVendor, colorByVendor, numberByVendor, logoByVendor)}
       <table class="legend"><thead><tr><th></th><th>vendor</th><th class="num">${legendMeasureHead}</th></tr></thead><tbody>${legendRows}</tbody></table>
     </div>
     <div class="map-tip" id="map-tip" hidden></div>