fullstackgtm 0.31.0 → 0.32.0

package/dist/cli.js

@@ -20,6 +20,7 @@ import { auditReportToHtml, auditReportToMarkdown } from "./report.js";
 import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall, suggestCallDeal } from "./calls.js";
+import { classifyCall, rubricForCallType, rubricPresets, CALL_TYPES, CALL_TYPE_IDS, } from "./callTypes.js";
 import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadCaptureTexts, loadMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
 import { assessAxes, axesReportToText } from "./marketAxes.js";
 import { computeDirectives, computeOverlayStats, directivesToPlan, overlayToMarkdown, } from "./marketOverlay.js";
@@ -27,7 +28,7 @@ import { computeScaleIndex, scaleReportToText } from "./marketScale.js";
 import { suggestMarketConfig } from "./marketTaxonomy.js";
 import { buildWorksheet, classifyMarket } from "./marketClassify.js";
 import { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
-import { DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
+import { DEFAULT_RUBRIC, classifyCallLlm, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
 import { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, latestStamps, loadEnrichConfig, parseCsv, resolveCrmField, selectStaleWork, stagedSourceRecords, staleDaysFor, } from "./enrich.js";
 import { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, } from "./enrichApollo.js";
 import { computeMissedFirings, createFileScheduleRunStore, createFileScheduleStore, nextCronFiring, parseCron, renderManagedBlock, replaceManagedBlock, assertSingleLineLabel, hasControlChar, scheduleId, systemCrontabIo, tokenizeCommand, validateSchedulableArgv, } from "./schedule.js";
@@ -60,7 +61,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
@@ -517,14 +519,20 @@ function parseValueOverrides(args) {
 async function callCommand(args) {
     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;
     }
     const loadParsedCall = async () => {
@@ -559,6 +567,56 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
             extractor: `llm:${credential.provider}:${model}`,
         });
     };
+    // Reconstruct plain transcript text from either a --transcript file (any
+    // dialect, normalized) or a parsed --call JSON. Shared by classify + score.
+    const loadTranscriptText = () => {
+        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"));
+        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 = 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");
@@ -644,9 +702,13 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
         return;
     }
     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;
         if (rubricPath) {
             const rubricRaw = readFileSync(resolve(process.cwd(), rubricPath), "utf8");
             try {
@@ -656,6 +718,10 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
                 throw new Error(`${rubricPath} is not a valid rubric: ${error instanceof Error ? error.message : String(error)} Expected JSON like { "scale": 5, "dimensions": [{ "name": "...", "weight": 1, "rubric": "..." }] }.`);
             }
         }
+        const callTypeOpt = option(rest, "--call-type");
+        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;
@@ -673,6 +739,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,
@@ -688,7 +765,7 @@ the free keyword baseline; score always needs a key (scoring is LLM work).`);
         console.log(renderScorecard(scorecard, title));
         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"})`);
 }
 /**
  * First-touch key onboarding: env vars win, then the credential store; on a
@@ -723,10 +800,14 @@ async function requireLlmCredential(command = "parse") {
     return { provider, apiKey };
 }
 function renderScorecard(scorecard, title) {
+    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/dist/index.d.ts

@@ -24,7 +24,8 @@ export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mapp
 export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.ts";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, type CallDealSuggestion, type CallInsightType, type ExtractedCallInsight, type ParsedCall, type ParsedTranscriptSegment, } from "./calls.ts";
 export { sampleSnapshot } from "./sampleData.ts";
-export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, type CallScorecard, type LlmCredential, type LlmExtractedInsight, type LlmProvider, type Rubric, type ScoredDimension, } from "./llm.ts";
+export { DEFAULT_MODELS, DEFAULT_RUBRIC, classifyCallLlm, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, 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, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadCaptureTexts, loadMarketConfig, marketHome, normalizeForMatch, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, type CaptureEntry, type CaptureOptions, type ClaimFront, type ClaimIntensity, type FrontDrift, type FrontState, type MarketAxis, type MarketClaim, type MarketConfig, type MarketObservation, type MarketVendor, type ObservationConfidence, type ObservationSet, type ObservationStore, type ScaleSignal, type SpanVerificationFailure, } from "./market.ts";
 export { suggestMarketConfig, type SeedVendor, type SuggestTaxonomyOptions, type SuggestTaxonomyResult, } from "./marketTaxonomy.ts";

package/dist/index.js

@@ -24,7 +24,8 @@ export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mapp
 export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.js";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, } from "./calls.js";
 export { sampleSnapshot } from "./sampleData.js";
-export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
+export { DEFAULT_MODELS, DEFAULT_RUBRIC, classifyCallLlm, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
+export { classifyCall, rubricForCallType, rubricPresets, bandForScore, CALL_TYPES, CALL_TYPE_IDS, BANDS_5, } from "./callTypes.js";
 export { resolveRecord } from "./resolve.js";
 export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadCaptureTexts, loadMarketConfig, marketHome, normalizeForMatch, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
 export { suggestMarketConfig, } from "./marketTaxonomy.js";

package/dist/llm.d.ts

@@ -1,4 +1,5 @@
 import type { ExtractedCallInsight } from "./calls.ts";
+import { type CallType } from "./callTypes.ts";
 /**
  * LLM-powered call extraction and scoring. Bring-your-own-key, two providers
  * (Anthropic, OpenAI), raw fetch — no SDK dependency, mirroring how the CRM
@@ -34,13 +35,34 @@ export declare function extractInsightsLlm(transcript: string, options: LlmCallO
     insights: LlmExtractedInsight[];
     model: string;
 }>;
+/** 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 declare const DEFAULT_RUBRIC: Rubric;
 export type ScoredDimension = {
@@ -56,6 +78,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;
@@ -64,6 +91,24 @@ export declare function scoreCallLlm(transcript: string, rubric: Rubric, options
     title?: string;
 }): Promise<CallScorecard>;
 export declare function parseRubric(json: string): Rubric;
+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 declare function classifyCallLlm(transcript: string, defs: Array<{
+    id: string;
+    name: string;
+    definition: string;
+}>, options: LlmCallOptions & {
+    title?: string;
+}): Promise<LlmCallClassification>;
 /**
  * Shared constrained-tool-call plumbing: force the model to answer through a
  * single tool whose input_schema is the output contract. Exported for other

package/dist/llm.js

@@ -1,4 +1,5 @@
 import { getCredential } from "./credentials.js";
+import { CALL_TYPE_IDS } from "./callTypes.js";
 export const DEFAULT_MODELS = {
     anthropic: "claude-haiku-4-5",
     openai: "gpt-4o-mini",
@@ -131,6 +132,7 @@ function actionGroundedInEvidence(text, evidence) {
 }
 export const DEFAULT_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)?" },
@@ -164,9 +166,19 @@ export async function scoreCallLlm(transcript, rubric, options) {
     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));
     const byName = new Map((result.dimensions ?? []).map((d) => [d.name, d]));
     const dimensions = rubric.dimensions.map((dim) => {
@@ -182,29 +194,75 @@ export async function scoreCallLlm(transcript, rubric, options) {
     });
     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) => Array.isArray(value) && value.length ? value.map((v) => String(v)) : undefined;
 export function parseRubric(json) {
     const parsed = JSON.parse(json);
     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." },
+    },
+};
+/**
+ * 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, defs, options) {
+    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));
+    return {
+        type: result.type ?? "other",
+        reason: result.reason ?? "Model did not give a reason.",
+        model,
+        method: "llm",
+    };
+}
 // ── Provider plumbing (raw fetch, forced tool calls) ───────────────────────
 /**
  * Shared constrained-tool-call plumbing: force the model to answer through a

package/dist/marketReport.js

@@ -158,7 +158,7 @@ function poleText(lines, x, y, anchorMode, fs) {
         .join("");
     return `<text class="ax-label" style="font-size:${fs}px" x="${x}" y="${y}" text-anchor="${anchorMode}">${spans}</text>`;
 }
-function svgScatter(points, ax, ay, anchor, colorByVendor, numberByVendor) {
+function svgScatter(points, ax, ay, anchor, colorByVendor, numberByVendor, logoByVendor) {
     const W = 640;
     const H = 480;
     const PAD_X = 56;
@@ -180,22 +180,42 @@ function svgScatter(points, ax, ay, anchor, colorByVendor, numberByVendor) {
     // 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 = [];
     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)}" 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("");
     const midX = ax.signed ? `<line class="grid" x1="${sx(0).toFixed(0)}" y1="${PAD_TOP}" x2="${sx(0).toFixed(0)}" y2="${H - PAD_BOTTOM}"/>` : "";
@@ -216,6 +236,7 @@ function svgScatter(points, ax, ay, anchor, colorByVendor, numberByVendor) {
     const yPos = yLabel(wrapPole(ay.positivePole, 26), PAD_TOP, "end");
     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}
@@ -344,7 +365,7 @@ function axisSectionsHtml(config, set) {
   <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>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Open-source agentic GTM ops framework: canonical GTM data model, pluggable deterministic audits, reviewable dry-run patch plans, approval-gated write-back with conflict detection, and cross-system entity resolution. HubSpot, Salesforce, and Stripe connectors included.",
   "license": "Apache-2.0",
   "author": "Full Stack GTM LLC <ryan@fullstackgtm.com> (https://fullstackgtm.com)",