fullstackgtm 0.44.0 → 0.46.0

package/src/healthScore.ts

@@ -0,0 +1,223 @@
+import type { AuditFindingSeverity, CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+
+/**
+ * Pure, node-free health scoring. Split from health.ts (which owns the
+ * fs-backed profile timeline) so V8-runtime consumers — the hosted app's
+ * Convex queries — can import the scoring math without pulling node built-ins,
+ * the same pattern as audit.ts/format.ts.
+ *
+ * The score is DETERMINISTIC (no LLM): same plan + same snapshot → same score,
+ * so it is stable in CI and comparable run-over-run.
+ */
+
+// Severity weights: a critical finding costs ~3× a warning, ~10× an info.
+const SEVERITY_WEIGHT: Record<AuditFindingSeverity, number> = { info: 1, warning: 3, critical: 10 };
+
+export type HealthEntry = {
+  /** ISO timestamp of the audit that produced this entry. */
+  at: string;
+  /** The saved plan this entry summarizes (correlates to plans/ and snapshots/). */
+  planId: string;
+  /** Deterministic 0–100 hygiene score (higher is healthier). */
+  score: number;
+  /** Total finding count across all rules. */
+  findings: number;
+  /** Severity-weighted finding total (drives the score). */
+  weightedFindings: number;
+  /** Record counts at audit time — the denominator that normalizes the score. */
+  records: { accounts: number; contacts: number; deals: number; total: number };
+  /** Finding count per rule id. */
+  byRule: Record<string, number>;
+  /** Finding count per severity. */
+  severityCounts: Record<AuditFindingSeverity, number>;
+  /**
+   * Per-object-type breakdown — so "is my contact data clean but my pipeline
+   * messy?" is answerable without re-auditing. Each type carries its own
+   * record-normalized score (same curve as the overall score, scoped to that
+   * type's records + findings).
+   */
+  byObjectType: Record<"account" | "contact" | "deal", {
+    records: number;
+    findings: number;
+    weightedFindings: number;
+    score: number;
+  }>;
+};
+
+export type HealthRuleDelta = {
+  ruleId: string;
+  current: number;
+  previous: number;
+  /** current − previous: positive = more findings (worse), negative = fewer (better). */
+  delta: number;
+};
+
+export type HealthRollup = {
+  profile: string;
+  auditCount: number;
+  first: string;
+  latest: string;
+  current: HealthEntry;
+  previous: HealthEntry | null;
+  /** current.score − previous.score: positive = improving. null on the first audit. */
+  scoreDelta: number | null;
+  ruleDeltas: HealthRuleDelta[];
+  history: Array<{ at: string; score: number; findings: number }>;
+};
+
+/**
+ * Deterministically score a saved audit. score = 100 / (1 + weighted findings
+ * per record): 0 findings → 100; one weighted finding per record → 50; the
+ * curve is bounded (0, 100], monotonic, and needs no clamping or magic
+ * constants. A messy 50-record CRM scores worse than the same finding count
+ * across 5,000 records, which is the point.
+ */
+export function computeHealth(plan: PatchPlan, snapshot: CanonicalGtmSnapshot, at: string): HealthEntry {
+  const byRule: Record<string, number> = {};
+  const severityCounts: Record<AuditFindingSeverity, number> = { info: 0, warning: 0, critical: 0 };
+  const typeTally: Record<"account" | "contact" | "deal", { findings: number; weightedFindings: number }> = {
+    account: { findings: 0, weightedFindings: 0 },
+    contact: { findings: 0, weightedFindings: 0 },
+    deal: { findings: 0, weightedFindings: 0 },
+  };
+  let weightedFindings = 0;
+  for (const finding of plan.findings) {
+    byRule[finding.ruleId] = (byRule[finding.ruleId] ?? 0) + 1;
+    severityCounts[finding.severity] += 1;
+    weightedFindings += SEVERITY_WEIGHT[finding.severity];
+    const t = finding.objectType;
+    if (t === "account" || t === "contact" || t === "deal") {
+      typeTally[t].findings += 1;
+      typeTally[t].weightedFindings += SEVERITY_WEIGHT[finding.severity];
+    }
+  }
+
+  const records = {
+    accounts: snapshot.accounts.length,
+    contacts: snapshot.contacts.length,
+    deals: snapshot.deals.length,
+    total: snapshot.accounts.length + snapshot.contacts.length + snapshot.deals.length,
+  };
+
+  const scoreFor = (weighted: number, recordCount: number) =>
+    Math.round(100 / (1 + weighted / Math.max(recordCount, 1)));
+  const recordsByType = { account: records.accounts, contact: records.contacts, deal: records.deals };
+  const byObjectType = (["account", "contact", "deal"] as const).reduce(
+    (acc, t) => {
+      acc[t] = {
+        records: recordsByType[t],
+        findings: typeTally[t].findings,
+        weightedFindings: typeTally[t].weightedFindings,
+        score: scoreFor(typeTally[t].weightedFindings, recordsByType[t]),
+      };
+      return acc;
+    },
+    {} as HealthEntry["byObjectType"],
+  );
+
+  const score = scoreFor(weightedFindings, records.total);
+
+  return {
+    at,
+    planId: plan.id,
+    score,
+    findings: plan.findings.length,
+    weightedFindings,
+    records,
+    byRule,
+    severityCounts,
+    byObjectType,
+  };
+}
+
+/** Roll a timeline up into the current state, the change since last time, and per-rule deltas. */
+export function summarizeHealth(entries: HealthEntry[], profile: string): HealthRollup | null {
+  if (entries.length === 0) return null;
+  // Oldest → newest, so `current` is the last entry.
+  const sorted = [...entries].sort((a, b) => a.at.localeCompare(b.at));
+  const current = sorted[sorted.length - 1];
+  const previous = sorted.length > 1 ? sorted[sorted.length - 2] : null;
+
+  const ruleIds = new Set<string>([
+    ...Object.keys(current.byRule),
+    ...(previous ? Object.keys(previous.byRule) : []),
+  ]);
+  const ruleDeltas: HealthRuleDelta[] = [...ruleIds]
+    .map((ruleId) => {
+      const cur = current.byRule[ruleId] ?? 0;
+      const prev = previous?.byRule[ruleId] ?? 0;
+      return { ruleId, current: cur, previous: prev, delta: cur - prev };
+    })
+    .sort((a, b) => b.current - a.current || a.ruleId.localeCompare(b.ruleId));
+
+  return {
+    profile,
+    auditCount: sorted.length,
+    first: sorted[0].at,
+    latest: current.at,
+    current,
+    previous,
+    scoreDelta: previous ? current.score - previous.score : null,
+    ruleDeltas,
+    history: sorted.map((entry) => ({ at: entry.at, score: entry.score, findings: entry.findings })),
+  };
+}
+
+// Sign-based and uniform: ▲ = the number went up, ▼ = down. The reader supplies
+// the meaning (score up = good; findings up = bad) — mixing arrow direction with
+// good/bad reads as contradictory ("▲ -3").
+function arrow(delta: number): string {
+  if (delta === 0) return "·";
+  return delta > 0 ? "▲" : "▼";
+}
+
+/** Human-readable rollup: headline score + trend, then per-rule change since last audit. */
+export function healthToMarkdown(rollup: HealthRollup): string {
+  const { current, scoreDelta } = rollup;
+  const lines = [`# GTM health — profile \`${rollup.profile}\``, ""];
+
+  const deltaText =
+    scoreDelta === null
+      ? "(first audit — no prior reading)"
+      : `${arrow(scoreDelta)} ${scoreDelta >= 0 ? "+" : ""}${scoreDelta} since the previous audit`;
+  lines.push(
+    `Score: **${current.score}/100** ${deltaText}`,
+    `Audits: ${rollup.auditCount} over ${shortDate(rollup.first)} → ${shortDate(rollup.latest)}`,
+    `Findings: ${current.findings} (${current.severityCounts.critical} critical, ${current.severityCounts.warning} warning, ${current.severityCounts.info} info)`,
+    `Records: ${current.records.accounts} accounts, ${current.records.contacts} contacts, ${current.records.deals} deals`,
+    "",
+  );
+
+  lines.push("## By object type", "", "| Type | Score | Findings | Records |", "| --- | --- | --- | --- |");
+  for (const t of ["account", "contact", "deal"] as const) {
+    const b = current.byObjectType[t];
+    lines.push(`| ${t} | ${b.score}/100 | ${b.findings} | ${b.records} |`);
+  }
+  lines.push("");
+
+  if (rollup.history.length > 1) {
+    lines.push("## Trend", "");
+    for (const point of rollup.history) {
+      const marker = point.at === rollup.latest ? "  ← latest" : "";
+      lines.push(`- ${shortDate(point.at)}  score ${point.score}  (${point.findings} findings)${marker}`);
+    }
+    lines.push("");
+  }
+
+  if (rollup.ruleDeltas.length > 0) {
+    lines.push("## By rule (Δ since previous audit)", "", "| Rule | Findings | Δ |", "| --- | --- | --- |");
+    for (const rule of rollup.ruleDeltas) {
+      const sign = rule.delta > 0 ? `+${rule.delta}` : `${rule.delta}`;
+      const cell = rule.delta === 0 ? "·" : `${arrow(rule.delta)} ${sign}`;
+      lines.push(`| ${rule.ruleId} | ${rule.current} | ${cell} |`);
+    }
+    lines.push("");
+  }
+
+  lines.push("> Score is deterministic: 100 / (1 + severity-weighted findings per record). Lower findings or more clean records ⇒ higher score.");
+  return `${lines.join("\n")}\n`;
+}
+
+function shortDate(iso: string): string {
+  return iso.slice(0, 10);
+}

package/src/icp.ts

@@ -158,26 +158,10 @@ export function icpToTheirStackFilters(icp: Icp): {
   return f;
 }
 
-/**
- * Crustdata / LinkedIn seniority vocab. ICP job levels are normalized lowercase;
- * Crustdata expects these exact capitalized strings (verified: "CXO",
- * "Vice President", "Director" appear in Crustdata's docs/examples).
- */
-const CRUSTDATA_SENIORITY: Record<string, string> = {
-  cxo: "CXO",
-  "c-suite": "CXO",
-  c_suite: "CXO",
-  founder: "Owner",
-  owner: "Owner",
-  partner: "Partner",
-  vp: "Vice President",
-  "vice president": "Vice President",
-  head: "Director",
-  director: "Director",
-  manager: "Manager",
-  senior: "Senior",
-  entry: "Entry",
-};
+// NOTE: a CRUSTDATA_SENIORITY vocab table lived here until 2026-07-02 — the
+// `current_seniority_levels` filter is broken upstream (see the live findings
+// on icpToCrustdataFilters below), so job levels are no longer sent to the
+// provider at all. Resurrect the table from git history if pipe0 fixes it.
 
 /**
  * ICP industry keyword → LinkedIn industry names Crustdata filters on.
@@ -212,18 +196,22 @@ const CRUSTDATA_INDUSTRY: Record<string, string[]> = {
 /**
  * pipe0 Crustdata people-search config.filters from the ICP. `current_job_titles`
  * matches real LinkedIn title strings (case-sensitive), so keywords are Title
- * Cased. Seniority + industry are mapped to Crustdata's controlled vocab via the
- * tables above.
+ * Cased. Industry is mapped to Crustdata's controlled vocab via the table above.
  *
- * LIVE FINDINGS (2026-06-26): `current_job_titles` is confirmed working (a
- * titles-only RevOps search returns results); `current_title` is rejected (422).
- * The full ICP filter returned 0 — the prime suspect is the industry vocab
- * (LinkedIn v1/v2 taxonomy mismatch), now hedged by sending BOTH generations in
- * CRUSTDATA_INDUSTRY above. NOT yet re-confirmed end-to-end (pipe0 credits were
- * exhausted mid-investigation) — re-run `enrich acquire --source pipe0` once
- * credits refill; if it still returns 0, the next suspects are the
- * `current_seniority_levels` shape/values and `locations`. Note fit-scoring backs
- * up PERSONA precision but NOT industry, so the industry filter is load-bearing.
+ * LIVE FINDINGS (2026-06-26, re-confirmed 2026-07-02 with fresh credits):
+ * `current_job_titles` works; `current_title` is rejected (422). The culprit
+ * that zeroed the full ICP filter is `current_seniority_levels`: ANY non-empty
+ * `include` returns 0 results through pipe0's people:profiles:crustdata@1 —
+ * including Crustdata's own documented values ("CXO", "Director",
+ * "Vice President"), lowercase, and SNAKE_CASE variants — while the identical
+ * search without it returns results. (An array instead of the
+ * {include, exclude} object is a 422, so the shape was right; the filter is
+ * broken upstream.) So job levels are NOT sent to the provider: persona
+ * seniority is enforced by fit scoring (scoreProspectAgainstIcp weights
+ * jobLevels), which was always the precision backstop. `locations` and
+ * `current_employers_linkedin_industries` (both-taxonomy hedge) are live-
+ * verified working in combination with titles. Note fit-scoring backs up
+ * PERSONA precision but NOT industry, so the industry filter is load-bearing.
  */
 export function icpToCrustdataFilters(icp: Icp): Record<string, unknown> {
   const f: Record<string, unknown> = {};
@@ -231,10 +219,6 @@ export function icpToCrustdataFilters(icp: Icp): Record<string, unknown> {
   if (icp.firmographics.geos?.length) {
     f.locations = icp.firmographics.geos.map((g) => COUNTRY_NAMES[g.toLowerCase()] ?? g);
   }
-  if (icp.persona.jobLevels?.length) {
-    const include = [...new Set(icp.persona.jobLevels.map((l) => CRUSTDATA_SENIORITY[l.toLowerCase()]).filter(Boolean))];
-    if (include.length) f.current_seniority_levels = { include, exclude: [] };
-  }
   if (icp.firmographics.industries?.length) {
     const inds = [
       ...new Set(icp.firmographics.industries.flatMap((i) => CRUSTDATA_INDUSTRY[i.toLowerCase()] ?? [titleCase(i)])),

package/src/index.ts

@@ -21,6 +21,20 @@ export {
   type LoadedConfig,
 } from "./config.ts";
 export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
+export {
+  APPLY_STAGES,
+  BACKFILL_STRIPE_STAGES,
+  composeListeners,
+  createProgressEmitter,
+  CRM_SYNC_STAGES,
+  nullProgressEmitter,
+  SNAPSHOT_PULL_STAGES,
+  STRIPE_SNAPSHOT_STAGES,
+  type ProgressEmitter,
+  type ProgressEvent,
+  type ProgressListener,
+  type ProgressSnapshot,
+} from "./progress.ts";
 export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";
 export {
   DEFAULT_LOOPBACK_PORT,
@@ -45,7 +59,20 @@ export {
   type SalesforceDeviceAuthorization,
   type SalesforceTokenSet,
 } from "./connectors/salesforceAuth.ts";
-export { createStripeConnector, type StripeConnectorOptions } from "./connectors/stripe.ts";
+export {
+  createStripeConnector,
+  fetchStripePaidInvoices,
+  type StripeConnectorOptions,
+  type StripePaidInvoice,
+} from "./connectors/stripe.ts";
+export {
+  buildStripeBackfillPlan,
+  DEFAULT_BACKFILL_MATCH_PROPERTY,
+  type StripeBackfillCounts,
+  type StripeBackfillOptions,
+  type StripeBackfillResult,
+  type StripeBackfillUnmatched,
+} from "./backfill.ts";
 export {
   activeProfile,
   credentialsDir,

package/src/judge.ts

@@ -612,6 +612,8 @@ export async function judgeSignals(opts: {
   promptTemplate?: string;
   llm?: LlmCallOptions;
   now?: Date;
+  /** Per-account progress (presentation only — a throwing callback never fails the run). */
+  onAccount?: (done: number, total: number, domain: string) => void;
 }): Promise<JudgeDecision[]> {
   const now = opts.now ?? new Date();
   const signalsById = new Map(opts.signals.map((s) => [s.id, s]));
@@ -629,6 +631,11 @@ export async function judgeSignals(opts: {
 
   const decisions: JudgeDecision[] = [];
   for (const [domain, signals] of byAccount) {
+    try {
+      opts.onAccount?.(decisions.length, byAccount.size, domain);
+    } catch {
+      // progress is presentation-only
+    }
     // Memory + fit stay gated on --with-history (scoring semantics unchanged).
     const recentlyTouched =
       opts.withHistory && opts.snapshot ? accountRecentlyTouched(domain, opts.snapshot, now) : false;

package/src/llm.ts

@@ -511,3 +511,242 @@ export async function validateLlmKey(
     ? { ok: true, detail: `Key accepted by the ${provider} API.` }
     : { ok: false, detail: `HTTP ${response.status} ${response.statusText}`.trim() };
 }
+
+// ── Chunked extraction (the TamTone "langextract" method) ───────────────────
+//
+// The quality property this encodes, validated on real call corpora in
+// TamTone: transcripts are never sent whole. They are chopped into small
+// (~1,500-char) speaker-turn-respecting chunks and each chunk gets its own
+// focused extraction call — small chunks yielded ~95% more grounded signals
+// than 4,000-char chunks in TamTone's testing, and whole-transcript passes
+// (this module's original extractInsightsLlm, kept for tiny inputs) are the
+// worst case: truncation drops the tail and one context window extracts
+// shallowly. Per-chunk results pass the SAME verbatim-evidence and
+// next-step-grounding gates as the single-shot path (checked against the
+// chunk they came from), then a TamTone-style quality score
+// (0.25·length + 0.40·specificity + 0.35·confidence, reject < 0.15) filters
+// filler before per-call dedupe and ranking.
+
+const CHUNK_MAX_CHARS = 1500;
+const CHUNK_CONCURRENCY = 4;
+const MAX_CHUNKS_PER_CALL = 80; // cost bound ≈ 120K chars of transcript
+const MAX_INSIGHTS_PER_CALL = 40;
+
+/**
+ * Chop a "Speaker: text" transcript into ≤maxChars chunks on speaker-turn
+ * (line) boundaries; a single oversize turn splits on sentence boundaries.
+ * No overlap (per-chunk extraction + downstream dedupe make it unnecessary).
+ */
+export function chunkTranscript(transcript: string, maxChars = CHUNK_MAX_CHARS): string[] {
+  const lines = transcript.split("\n").filter((line) => line.trim().length > 0);
+  const pieces: string[] = [];
+  for (const line of lines) {
+    if (line.length <= maxChars) {
+      pieces.push(line);
+      continue;
+    }
+    // Oversize turn: split on sentence boundaries within the budget.
+    let rest = line;
+    while (rest.length > maxChars) {
+      const window = rest.slice(0, maxChars);
+      const cut = Math.max(
+        window.lastIndexOf(". "),
+        window.lastIndexOf("? "),
+        window.lastIndexOf("! "),
+      );
+      const at = cut >= maxChars * 0.4 ? cut + 1 : maxChars;
+      pieces.push(rest.slice(0, at).trim());
+      rest = rest.slice(at).trim();
+    }
+    if (rest) pieces.push(rest);
+  }
+
+  const chunks: string[] = [];
+  let current = "";
+  for (const piece of pieces) {
+    if (current && current.length + piece.length + 1 > maxChars) {
+      chunks.push(current);
+      current = piece;
+    } else {
+      current = current ? `${current}\n${piece}` : piece;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
+
+// Few-shot examples are load-bearing (TamTone's extractor refuses to run
+// without an example set): they anchor the "verbatim span, not paraphrase"
+// contract and calibrate what NOT to extract far better than instructions.
+const CHUNK_FEW_SHOT = `Examples:
+
+Excerpt: "Prospect: honestly the big blocker is that our reps spend every Friday cleaning the pipeline by hand. Rep: how long does that take? Prospect: most of the day, easily five or six hours."
+→ [{"type":"pain_point","text":"Reps lose ~5-6 hours every Friday manually cleaning the pipeline.","evidence":"our reps spend every Friday cleaning the pipeline by hand","speaker":"Prospect","importance":4,"confidence":0.9}]
+
+Excerpt: "Prospect: we're also looking at Clari for this. Their forecasting is strong but the rollout quote scared us. Rep: what was the number? Prospect: about eighty thousand a year."
+→ [{"type":"competitor_mention","text":"Evaluating Clari; strong forecasting but ~$80K/yr rollout quote is a concern.","evidence":"we're also looking at Clari for this","speaker":"Prospect","importance":4,"confidence":0.9},{"type":"pricing","text":"Clari quoted about $80K per year.","evidence":"about eighty thousand a year","speaker":"Prospect","importance":3,"confidence":0.85}]
+
+Excerpt: "Rep: I'll send the security questionnaire answers by Thursday. Prospect: perfect, and I'll get you time with our CFO next week."
+→ [{"type":"next_step","text":"Rep to send security questionnaire answers by Thursday.","evidence":"I'll send the security questionnaire answers by Thursday","speaker":"Rep","importance":4,"confidence":0.95,"owner":"Rep","deadline":"Thursday","commitment":"firm"},{"type":"next_step","text":"Prospect to schedule time with their CFO next week.","evidence":"I'll get you time with our CFO next week","speaker":"Prospect","importance":4,"confidence":0.9,"owner":"Prospect","deadline":"next week","commitment":"firm"}]
+
+Excerpt: "Rep: how was the long weekend? Prospect: great, we took the kids camping. Rep: nice! okay, let me share my screen."
+→ []
+
+Do NOT extract: greetings, scheduling chatter, filler ("yeah", "makes sense"), screen-share logistics, or anything you cannot quote verbatim from THIS excerpt.`;
+
+function chunkInstructions(index: number, total: number, title?: string): string {
+  return `${EXTRACT_INSTRUCTIONS}
+
+You are seeing excerpt ${index + 1} of ${total} from a longer call${title ? ` ("${title}")` : ""}.
+Extract ONLY what this excerpt itself grounds — the other excerpts are handled separately.
+evidence MUST be a verbatim span of THIS excerpt.
+
+${CHUNK_FEW_SHOT}`;
+}
+
+// TamTone quality gate (analysis/quality_scorer.py):
+// 0.25·length + 0.40·specificity + 0.35·confidence, hard caps for
+// stopword-only/too-short, reject below 0.15. Specificity rewards the
+// concrete: numbers, money, dates/durations, named things.
+const STOPWORDS = new Set(
+  "a an and are as at be but by for from had has have i if in into is it its me my not of on or our so that the their them they this to was we were what when which who will with you your yeah okay right sure like just really kind sort".split(" "),
+);
+
+export function scoreInsightQuality(insight: { text: string; evidence: string; confidence: number }): number {
+  const text = `${insight.text} ${insight.evidence}`.trim();
+  const words = text.toLowerCase().split(/[^a-z0-9$%']+/).filter(Boolean);
+  if (text.length < 5) return 0.1;
+  const nonStop = words.filter((word) => !STOPWORDS.has(word));
+  if (nonStop.length === 0) return 0.1;
+
+  const lengthScore = Math.min(1, words.length / 20);
+  let specificity = 0;
+  if (/\d/.test(text)) specificity += 0.3; // numbers/amounts/dates
+  if (/[$€£]|\b(dollars?|thousand|million|percent|%)\b/i.test(text)) specificity += 0.2;
+  if (/\b(q[1-4]|january|february|march|april|may|june|july|august|september|october|november|december|week|month|quarter|year|monday|tuesday|wednesday|thursday|friday)\b/i.test(text)) specificity += 0.2;
+  if (/\b[A-Z][a-z]{2,}/.test(insight.text.slice(1))) specificity += 0.15; // named things
+  specificity += Math.min(0.3, nonStop.length / 40);
+  specificity = Math.min(1, specificity);
+
+  return 0.25 * lengthScore + 0.4 * specificity + 0.35 * Math.min(1, Math.max(0, insight.confidence));
+}
+
+const QUALITY_REJECT_BELOW = 0.15;
+
+export type ChunkedExtractResult = {
+  insights: LlmExtractedInsight[];
+  model: string;
+  chunks: number;
+  chunksUsed: number;
+  chunksFailed: number;
+};
+
+/**
+ * The chunked pipeline: chunk → per-chunk forced-tool extraction (bounded
+ * concurrency) → per-chunk verbatim + grounding gates → quality gate →
+ * per-call dedupe → rank. A failed chunk is skipped (best-effort); only
+ * all-chunks-failed throws.
+ */
+export async function extractInsightsChunked(
+  transcript: string,
+  options: LlmCallOptions & { title?: string; maxChunks?: number; concurrency?: number },
+): Promise<ChunkedExtractResult> {
+  const model = options.model ?? DEFAULT_MODELS[options.provider];
+  const allChunks = chunkTranscript(transcript);
+  const chunks = allChunks.slice(0, options.maxChunks ?? MAX_CHUNKS_PER_CALL);
+  if (chunks.length <= 1) {
+    // Tiny transcript: the single-shot path is identical work with one call.
+    const single = await extractInsightsLlm(transcript, options);
+    return { ...single, chunks: allChunks.length, chunksUsed: chunks.length, chunksFailed: 0 };
+  }
+
+  const concurrency = Math.max(1, options.concurrency ?? CHUNK_CONCURRENCY);
+  const perChunk: LlmExtractedInsight[][] = new Array(chunks.length);
+  let failed = 0;
+  let cursor = 0;
+  async function worker() {
+    while (cursor < chunks.length) {
+      const index = cursor;
+      cursor += 1;
+      const chunk = chunks[index];
+      try {
+        const result = (await forcedToolCall(
+          `${chunkInstructions(index, chunks.length, options.title)}\n\nExcerpt:\n${chunk}`,
+          "extract_call_insights",
+          EXTRACT_SCHEMA,
+          model,
+          options,
+        )) as { insights?: LlmExtractedInsight[] };
+        const normalizedChunk = normalizeSpan(chunk);
+        perChunk[index] = (result.insights ?? [])
+          .filter((insight) => INSIGHT_TYPES.includes(insight.type))
+          // The SAME gates as the single-shot path, applied per chunk: the
+          // evidence must be a verbatim span of the chunk it came from, and a
+          // next_step's written action must be grounded in that evidence.
+          .filter((insight) => {
+            const quote = normalizeSpan(insight.evidence ?? "");
+            return quote.length >= 12 && normalizedChunk.includes(quote);
+          })
+          .filter(
+            (insight) =>
+              insight.type !== "next_step" ||
+              actionGroundedInEvidence(insight.text, insight.evidence ?? ""),
+          )
+          .map((insight) => ({
+            ...insight,
+            title: insight.type.replace(/_/g, " "),
+            importance: clamp(Math.round(insight.importance ?? 3), 1, 5),
+            confidence: clamp(insight.confidence ?? 0.7, 0, 1),
+          }))
+          .filter((insight) => scoreInsightQuality(insight) >= QUALITY_REJECT_BELOW);
+      } catch {
+        failed += 1;
+        perChunk[index] = [];
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, worker));
+
+  if (failed === chunks.length) {
+    throw new Error(`LLM extraction failed for all ${chunks.length} chunks.`);
+  }
+
+  // Per-call dedupe: exact on (type, normalized evidence), then near-dup on
+  // (type, normalized text) containment — chunks don't overlap, so dupes are
+  // the model restating the same fact from adjacent context.
+  const seen = new Map<string, LlmExtractedInsight>();
+  const richness = (insight: LlmExtractedInsight) =>
+    insight.confidence +
+    (insight.owner ? 0.05 : 0) +
+    (insight.deadline ? 0.05 : 0) +
+    (insight.speaker ? 0.02 : 0);
+  for (const insights of perChunk) {
+    for (const insight of insights ?? []) {
+      const key = `${insight.type}:${normalizeSpan(insight.evidence ?? "")}`;
+      const kept = seen.get(key);
+      // Same grounded fact stated twice: keep the richer statement (owner/
+      // deadline/speaker attached, higher confidence), not the first seen.
+      if (!kept || richness(insight) > richness(kept)) seen.set(key, insight);
+    }
+  }
+  const merged: LlmExtractedInsight[] = [];
+  for (const insight of seen.values()) {
+    const text = normalizeSpan(insight.text);
+    const dupe = merged.find(
+      (kept) =>
+        kept.type === insight.type &&
+        (normalizeSpan(kept.text).includes(text) || text.includes(normalizeSpan(kept.text))),
+    );
+    if (!dupe) merged.push(insight);
+    else if (insight.importance > dupe.importance) merged[merged.indexOf(dupe)] = insight;
+  }
+
+  merged.sort((a, b) => b.importance - a.importance || b.confidence - a.confidence);
+  return {
+    insights: merged.slice(0, MAX_INSIGHTS_PER_CALL),
+    model,
+    chunks: allChunks.length,
+    chunksUsed: chunks.length,
+    chunksFailed: failed,
+  };
+}