fullstackgtm 0.45.0 → 0.47.0

package/dist/health.js

@@ -1,6 +1,10 @@
 import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { activeProfile, credentialsDir, ensureSecureHomeDir, writeSecureFile } from "./credentials.js";
+// Pure scoring lives in healthScore.ts (node-free, importable from V8 runtimes
+// like the hosted app's Convex queries); this module owns the fs-backed
+// profile timeline. Re-exported so existing imports keep working.
+export { computeHealth, summarizeHealth, healthToMarkdown, } from "./healthScore.js";
 /**
  * The engagement workspace: a per-client health timeline that accrues from the
  * verb people already run (`audit --save`). State lives in the profile dir
@@ -11,140 +15,6 @@ import { activeProfile, credentialsDir, ensureSecureHomeDir, writeSecureFile } f
  * 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 = { info: 1, warning: 3, critical: 10 };
-/**
- * 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, snapshot, at) {
-    const byRule = {};
-    const severityCounts = { info: 0, warning: 0, critical: 0 };
-    const typeTally = {
-        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, recordCount) => 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"].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;
-    }, {});
-    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, profile) {
-    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([
-        ...Object.keys(current.byRule),
-        ...(previous ? Object.keys(previous.byRule) : []),
-    ]);
-    const ruleDeltas = [...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) {
-    if (delta === 0)
-        return "·";
-    return delta > 0 ? "▲" : "▼";
-}
-/** Human-readable rollup: headline score + trend, then per-rule change since last audit. */
-export function healthToMarkdown(rollup) {
-    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"]) {
-        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) {
-    return iso.slice(0, 10);
-}
 // ── Profile-scoped storage ──────────────────────────────────────────────────
 /** `$FSGTM_HOME[/profiles/<name>]/health.jsonl` — append-only, one entry per audit-save. */
 export function healthFilePath() {

package/dist/healthScore.d.ts

@@ -0,0 +1,71 @@
+import type { AuditFindingSeverity, CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+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 declare function computeHealth(plan: PatchPlan, snapshot: CanonicalGtmSnapshot, at: string): HealthEntry;
+/** Roll a timeline up into the current state, the change since last time, and per-rule deltas. */
+export declare function summarizeHealth(entries: HealthEntry[], profile: string): HealthRollup | null;
+/** Human-readable rollup: headline score + trend, then per-rule change since last audit. */
+export declare function healthToMarkdown(rollup: HealthRollup): string;

package/dist/healthScore.js

@@ -0,0 +1,143 @@
+/**
+ * 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 = { info: 1, warning: 3, critical: 10 };
+/**
+ * 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, snapshot, at) {
+    const byRule = {};
+    const severityCounts = { info: 0, warning: 0, critical: 0 };
+    const typeTally = {
+        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, recordCount) => 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"].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;
+    }, {});
+    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, profile) {
+    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([
+        ...Object.keys(current.byRule),
+        ...(previous ? Object.keys(previous.byRule) : []),
+    ]);
+    const ruleDeltas = [...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) {
+    if (delta === 0)
+        return "·";
+    return delta > 0 ? "▲" : "▼";
+}
+/** Human-readable rollup: headline score + trend, then per-rule change since last audit. */
+export function healthToMarkdown(rollup) {
+    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"]) {
+        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) {
+    return iso.slice(0, 10);
+}

package/dist/index.d.ts

@@ -5,11 +5,13 @@ export { buildDedupePlan, dedupeKey, type DedupeOptions } from "./dedupe.ts";
 export { buildReassignPlans, type ReassignObjectType, type ReassignOptions } from "./reassign.ts";
 export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, type FullstackgtmConfig, 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, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, type HubspotTokenSet, type LoopbackLoginOptions, } from "./connectors/hubspotAuth.ts";
 export { createSalesforceConnector, type SalesforceConnection, type SalesforceConnectorOptions, } from "./connectors/salesforce.ts";
 export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, 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, credentialsPath, DEFAULT_PROFILE, deleteCredential, getCredential, listProfiles, resolveHubspotAccessToken, resolveHubspotConnection, setActiveProfile, storeCredential, type HubspotConnection, type StoredCredential, } from "./credentials.ts";
 export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
 export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, type BuildEnrichPlanOptions, type EnrichAmbiguity, type EnrichConfig, type EnrichCounts, type EnrichFieldConfig, type EnrichMatchConfig, type EnrichMode, type EnrichObjectType, type EnrichPlanResult, type EnrichRun, type EnrichRunStore, type EnrichSourceConfig, type EnrichSourceRecord, type EnrichStamp, type EnrichWorkItem, type MatchOutcome, } from "./enrich.ts";

package/dist/index.js

@@ -5,11 +5,13 @@ export { buildDedupePlan, dedupeKey } from "./dedupe.js";
 export { buildReassignPlans } from "./reassign.js";
 export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, } from "./config.js";
 export { applyPatchPlan } from "./connector.js";
+export { APPLY_STAGES, BACKFILL_STRIPE_STAGES, composeListeners, createProgressEmitter, CRM_SYNC_STAGES, nullProgressEmitter, SNAPSHOT_PULL_STAGES, STRIPE_SNAPSHOT_STAGES, } from "./progress.js";
 export { createHubspotConnector } from "./connectors/hubspot.js";
 export { DEFAULT_LOOPBACK_PORT, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, } from "./connectors/hubspotAuth.js";
 export { createSalesforceConnector, } from "./connectors/salesforce.js";
 export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, } from "./connectors/salesforceAuth.js";
-export { createStripeConnector } from "./connectors/stripe.js";
+export { createStripeConnector, fetchStripePaidInvoices, } from "./connectors/stripe.js";
+export { buildStripeBackfillPlan, DEFAULT_BACKFILL_MATCH_PROPERTY, } from "./backfill.js";
 export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, deleteCredential, getCredential, listProfiles, resolveHubspotAccessToken, resolveHubspotConnection, setActiveProfile, storeCredential, } from "./credentials.js";
 export { generateDemoSnapshot } from "./demo.js";
 export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, } from "./enrich.js";

package/dist/llm.d.ts

@@ -134,3 +134,32 @@ export declare function validateLlmKey(provider: LlmProvider, apiKey: string, fe
     ok: boolean;
     detail: string;
 }>;
+/**
+ * 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 declare function chunkTranscript(transcript: string, maxChars?: number): string[];
+export declare function scoreInsightQuality(insight: {
+    text: string;
+    evidence: string;
+    confidence: number;
+}): number;
+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 declare function extractInsightsChunked(transcript: string, options: LlmCallOptions & {
+    title?: string;
+    maxChunks?: number;
+    concurrency?: number;
+}): Promise<ChunkedExtractResult>;

package/dist/llm.js

@@ -367,3 +367,209 @@ export async function validateLlmKey(provider, apiKey, fetchImpl = fetch) {
         ? { 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, maxChars = CHUNK_MAX_CHARS) {
+    const lines = transcript.split("\n").filter((line) => line.trim().length > 0);
+    const pieces = [];
+    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 = [];
+    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, total, title) {
+    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) {
+    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;
+/**
+ * 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, options) {
+    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 = 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));
+                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();
+    const richness = (insight) => 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 = [];
+    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,
+    };
+}