fullstackgtm 0.45.0 → 0.47.0

package/dist/connectors/salesforce.js

@@ -1,4 +1,5 @@
 import { SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, readMappedValue, } from "../mappings.js";
+import { SNAPSHOT_PULL_STAGES } from "../progress.js";
 const DEFAULT_API_VERSION = "v59.0";
 const SOBJECT_TYPES = {
     account: "Account",
@@ -16,6 +17,14 @@ const MAPPING_OBJECT_TYPES = {
     contact: "contacts",
     deal: "deals",
 };
+// SnapshotProgress object types → the shared SNAPSHOT_PULL_STAGES names, so
+// the CLI checklist and the app StageTimeline read the same stage labels.
+const PULL_STAGE_BY_TYPE = {
+    user: "owners",
+    account: "accounts",
+    contact: "contacts",
+    deal: "deals",
+};
 /**
  * Reference connector for Salesforce.
  *
@@ -144,7 +153,22 @@ export function createSalesforceConnector(options) {
         return mappedFields(mappings, objectType, SALESFORCE_DEFAULT_FIELD_MAPPINGS[objectType]).join(", ");
     }
     async function assembleSnapshot(whereClause) {
-        const progressFor = (objectType) => (fetched) => options.onProgress?.({ objectType, fetched });
+        // Per-page snapshot-pull progress: the legacy onProgress callback plus the
+        // shared emitter (stage on the first page of each object type, items per
+        // page). Both are presentation-only — `query` already swallows errors.
+        let lastPullStage;
+        const progressFor = (objectType) => (fetched) => {
+            options.onProgress?.({ objectType, fetched });
+            const emitter = options.progress;
+            if (!emitter)
+                return;
+            const stage = PULL_STAGE_BY_TYPE[objectType];
+            if (stage !== lastPullStage) {
+                lastPullStage = stage;
+                emitter.stage(stage, SNAPSHOT_PULL_STAGES.indexOf(stage), SNAPSHOT_PULL_STAGES.length);
+            }
+            emitter.items(fetched);
+        };
         const sfUsers = await query(`SELECT ${selectFields("owners")} FROM User${whereClause}`, progressFor("user"));
         const users = sfUsers.map((user) => {
             const id = String(readMapped(user, "owners", "id", "Id"));
@@ -235,6 +259,8 @@ export function createSalesforceConnector(options) {
                 raw: opportunity,
             };
         });
+        // Deliver any throttled trailing items heartbeat before the pull returns.
+        options.progress?.flush();
         return {
             generatedAt: new Date().toISOString(),
             provider: "salesforce",
@@ -350,6 +376,139 @@ export function createSalesforceConnector(options) {
             detail: `Deleted ${sobjectType}/${operation.objectId}.`,
         };
     }
+    function normalizeSalesforceValue(value) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        return String(value).split("T")[0];
+    }
+    function fieldMappingFor(operation) {
+        const sobjectType = SOBJECT_TYPES[operation.objectType];
+        const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+        if (!sobjectType || !mappingType || !operation.field)
+            return null;
+        const defaults = SALESFORCE_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+        return {
+            sobjectType,
+            field: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field),
+        };
+    }
+    function compositeErrorDetail(result) {
+        const errors = Array.isArray(result?.errors) ? result.errors : [];
+        const message = errors
+            .map((error) => [error?.statusCode, error?.message].filter(Boolean).join(": "))
+            .filter(Boolean)
+            .join("; ");
+        return message ? `Salesforce rejected this record: ${message.slice(0, 300)}.` : "Salesforce rejected this record.";
+    }
+    async function applySetFieldBatch(operations) {
+        const out = new Map();
+        const mapped = operations.map((operation) => ({ operation, mapping: fieldMappingFor(operation) }));
+        for (const item of mapped) {
+            if (!item.mapping) {
+                out.set(item.operation.id, {
+                    operationId: item.operation.id,
+                    status: "skipped",
+                    detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+                });
+            }
+        }
+        const clean = mapped.filter((item) => Boolean(item.mapping));
+        if (clean.length === 0)
+            return operations.map((operation) => out.get(operation.id));
+        const sobjectType = clean[0].mapping.sobjectType;
+        const fields = [...new Set(clean.map((item) => item.mapping.field))];
+        const liveById = new Map();
+        const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+        for (let i = 0; i < ids.length; i += 200) {
+            const idList = ids.slice(i, i + 200).map((id) => `'${id.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+            const rows = await query(`SELECT Id, ${fields.join(", ")} FROM ${sobjectType} WHERE Id IN (${idList})`);
+            for (const row of rows)
+                liveById.set(String(row.Id), row);
+        }
+        const toWrite = [];
+        for (const { operation, mapping } of clean) {
+            const row = liveById.get(operation.objectId);
+            const current = row?.[mapping.field] ?? null;
+            const expected = normalizeSalesforceValue(operation.beforeValue);
+            const found = normalizeSalesforceValue(current);
+            if (!row || expected !== found) {
+                out.set(operation.id, {
+                    operationId: operation.id,
+                    status: "conflict",
+                    detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+                    providerData: { currentValue: current ?? null },
+                });
+                continue;
+            }
+            toWrite.push({ operation, field: mapping.field });
+        }
+        for (let i = 0; i < toWrite.length; i += 200) {
+            const chunk = toWrite.slice(i, i + 200);
+            const records = chunk.map(({ operation, field }) => ({
+                attributes: { type: sobjectType },
+                Id: operation.objectId,
+                [field]: operation.operation === "clear_field" ? null : String(operation.afterValue ?? ""),
+            }));
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects`, {
+                    method: "PATCH",
+                    body: JSON.stringify({ allOrNone: false, records }),
+                }));
+            }
+            catch (error) {
+                for (const { operation } of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const { operation, field } = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Set ${field} on ${sobjectType}/${operation.objectId}.`, providerData: { sobjectType, field } }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+    }
+    async function applyArchiveBatch(operations) {
+        const sobjectType = SOBJECT_TYPES[operations[0]?.objectType];
+        if (!sobjectType)
+            return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+        const out = new Map();
+        for (let i = 0; i < operations.length; i += 200) {
+            const chunk = operations.slice(i, i + 200);
+            const ids = chunk.map((operation) => encodeURIComponent(operation.objectId)).join(",");
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects?ids=${ids}&allOrNone=false`, { method: "DELETE" }));
+            }
+            catch (error) {
+                for (const operation of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const operation = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Deleted ${sobjectType}/${operation.objectId}.` }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch delete did not process this operation." });
+    }
+    async function applyBatch(operations) {
+        if (operations.length === 0)
+            return [];
+        if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+            return applySetFieldBatch(operations);
+        }
+        if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+            return applyArchiveBatch(operations);
+        }
+        return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+    }
     function escapeXml(value) {
         return value
             .replace(/&/g, "&amp;")
@@ -451,7 +610,7 @@ export function createSalesforceConnector(options) {
             return { operationId: operation.id, status: "skipped", detail: "create_record needs a CreateRecordPayload afterValue." };
         }
         if (operation.objectType !== "contact" && operation.objectType !== "account") {
-            return { operationId: operation.id, status: "skipped", detail: "create_record supports contacts and accounts." };
+            return { operationId: operation.id, status: "skipped", detail: "create_record supports contacts and accounts on Salesforce (deal/Opportunity creation is HubSpot-only for now)." };
         }
         const matchValue = String(payload.matchValue ?? "").trim();
         if (!matchValue) {
@@ -712,6 +871,8 @@ export function createSalesforceConnector(options) {
         fetchChanges,
         applyOperation,
         applyCreateContactsBatch,
+        applyBatch,
+        applyBatchLimit: 200,
         readField,
     };
 }

package/dist/connectors/stripe.d.ts

@@ -1,10 +1,17 @@
 import type { GtmConnector } from "../types.ts";
+import { type ProgressEmitter } from "../progress.ts";
 export type StripeConnectorOptions = {
     /** Stripe secret key (sk_...) or restricted key. */
     getApiKey: () => string | Promise<string>;
     apiBaseUrl?: string;
     /** Injectable fetch for testing. */
     fetchImpl?: typeof fetch;
+    /**
+     * Shared progress vocabulary (src/progress.ts): the snapshot pull emits a
+     * `stage` per collection (customers, subscriptions) and an `items`
+     * heartbeat per page. Presentation-only — errors are swallowed.
+     */
+    progress?: ProgressEmitter;
 };
 /**
  * Read-only billing connector for Stripe — the first non-CRM connector,
@@ -25,3 +32,33 @@ export type StripeConnectorOptions = {
  *   collections are always empty.
  */
 export declare function createStripeConnector(options: StripeConnectorOptions): GtmConnector;
+/**
+ * One PAID Stripe invoice, normalized for the backfill plan builder
+ * (`backfill stripe`). Amounts are major units (Stripe returns cents);
+ * `paidAt` is the payment date (YYYY-MM-DD) from status_transitions.paid_at.
+ */
+export type StripePaidInvoice = {
+    id: string;
+    number?: string;
+    customerId?: string;
+    customerName?: string;
+    customerEmail?: string;
+    /** Lowercased domain of the customer's billing email — the CRM match key. */
+    customerDomain?: string;
+    /** Major currency units (amount_paid / 100). */
+    amountPaid: number;
+    currency?: string;
+    /** YYYY-MM-DD from status_transitions.paid_at (unix seconds). */
+    paidAt?: string;
+    description?: string;
+};
+/**
+ * Read-only pull of PAID invoices (GET /v1/invoices?status=paid with the
+ * customer expanded), the revenue source of truth the backfill plan builder
+ * turns into closed-won deal proposals. Invoices with a zero amount_paid or
+ * no id are skipped — a $0 invoice is not a won deal.
+ */
+export declare function fetchStripePaidInvoices(options: StripeConnectorOptions, opts?: {
+    sinceIso?: string;
+    onPage?: (fetched: number) => void;
+}): Promise<StripePaidInvoice[]>;

package/dist/connectors/stripe.js

@@ -1,4 +1,42 @@
+import { STRIPE_SNAPSHOT_STAGES } from "../progress.js";
 const DEFAULT_API_BASE_URL = "https://api.stripe.com";
+// Module-scope request/list (parameterized by options) so the connector
+// factory and fetchStripePaidInvoices share one implementation.
+async function stripeRequest(options, path) {
+    const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const apiKey = await options.getApiKey();
+    const response = await fetchImpl(`${baseUrl}${path}`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!response.ok) {
+        // Status line only — the body can echo request details bound to a live
+        // billing key, and these errors land in scheduled-run records.
+        await response.text().catch(() => undefined);
+        throw new Error(`Stripe API error ${response.status}. Check the restricted key and request.`);
+    }
+    return response.json();
+}
+/** Stripe list pagination: follow `has_more` with `starting_after=<last id>`. */
+async function stripeList(options, path, onPage) {
+    const results = [];
+    let startingAfter;
+    do {
+        const separator = path.includes("?") ? "&" : "?";
+        const data = await stripeRequest(options, `${path}${startingAfter ? `${separator}starting_after=${encodeURIComponent(startingAfter)}` : ""}`);
+        const page = data.data ?? [];
+        results.push(...page);
+        try {
+            onPage?.(results.length);
+        }
+        catch {
+            // progress is presentation-only; never let it fail a pull
+        }
+        startingAfter =
+            data.has_more === true && page.length > 0 ? String(page.at(-1).id) : undefined;
+    } while (startingAfter);
+    return results;
+}
 /**
  * Read-only billing connector for Stripe — the first non-CRM connector,
  * proving the GtmConnector contract generalizes to billing systems.
@@ -18,40 +56,16 @@ const DEFAULT_API_BASE_URL = "https://api.stripe.com";
  *   collections are always empty.
  */
 export function createStripeConnector(options) {
-    const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
-    const fetchImpl = options.fetchImpl ?? fetch;
-    async function request(path) {
-        const apiKey = await options.getApiKey();
-        const response = await fetchImpl(`${baseUrl}${path}`, {
-            headers: { Authorization: `Bearer ${apiKey}` },
-        });
-        if (!response.ok) {
-            // Status line only — the body can echo request details bound to a live
-            // billing key, and these errors land in scheduled-run records.
-            await response.text().catch(() => undefined);
-            throw new Error(`Stripe API error ${response.status}. Check the restricted key and request.`);
-        }
-        return response.json();
-    }
-    /** Stripe list pagination: follow `has_more` with `starting_after=<last id>`. */
-    async function list(path) {
-        const results = [];
-        let startingAfter;
-        do {
-            const separator = path.includes("?") ? "&" : "?";
-            const data = await request(`${path}${startingAfter ? `${separator}starting_after=${encodeURIComponent(startingAfter)}` : ""}`);
-            const page = data.data ?? [];
-            results.push(...page);
-            startingAfter =
-                data.has_more === true && page.length > 0 ? String(page.at(-1).id) : undefined;
-        } while (startingAfter);
-        return results;
-    }
+    const list = (path, onPage) => stripeList(options, path, onPage);
+    // Shared progress vocabulary: stage per collection, items per page.
+    const pullStage = (stage) => options.progress?.stage(stage, STRIPE_SNAPSHOT_STAGES.indexOf(stage), STRIPE_SNAPSHOT_STAGES.length);
+    const pullItems = (fetched) => options.progress?.items(fetched);
     async function assembleSnapshot(createdGte) {
         // Stripe filters list endpoints on the integer `created` field via
         // created[gte]=<unix seconds>; omitted on a full snapshot.
         const createdFilter = createdGte === undefined ? "" : `&created[gte]=${createdGte}`;
-        const customers = await list(`/v1/customers?limit=100${createdFilter}`);
+        pullStage("customers");
+        const customers = await list(`/v1/customers?limit=100${createdFilter}`, pullItems);
         const accounts = [];
         const contacts = [];
         for (const customer of customers) {
@@ -86,7 +100,8 @@ export function createStripeConnector(options) {
                 });
             }
         }
-        const subscriptions = await list(`/v1/subscriptions?status=all&limit=100${createdFilter}`);
+        pullStage("subscriptions");
+        const subscriptions = await list(`/v1/subscriptions?status=all&limit=100${createdFilter}`, pullItems);
         const deals = subscriptions
             .filter((subscription) => subscription.id)
             .map((subscription) => {
@@ -125,6 +140,8 @@ export function createStripeConnector(options) {
                 raw: subscription,
             };
         });
+        // Deliver any throttled trailing items heartbeat before the pull returns.
+        options.progress?.flush();
         return {
             generatedAt: new Date().toISOString(),
             provider: "stripe",
@@ -165,6 +182,61 @@ export function createStripeConnector(options) {
         applyOperation,
     };
 }
+/**
+ * Read-only pull of PAID invoices (GET /v1/invoices?status=paid with the
+ * customer expanded), the revenue source of truth the backfill plan builder
+ * turns into closed-won deal proposals. Invoices with a zero amount_paid or
+ * no id are skipped — a $0 invoice is not a won deal.
+ */
+export async function fetchStripePaidInvoices(options, opts = {}) {
+    let createdFilter = "";
+    if (opts.sinceIso !== undefined) {
+        const sinceMs = Date.parse(opts.sinceIso);
+        if (!Number.isFinite(sinceMs))
+            throw new Error(`Invalid since timestamp: ${opts.sinceIso}`);
+        createdFilter = `&created[gte]=${Math.floor(sinceMs / 1000)}`;
+    }
+    const invoices = await stripeList(options, `/v1/invoices?status=paid&limit=100&expand[]=data.customer${createdFilter}`, opts.onPage);
+    const paid = [];
+    for (const invoice of invoices) {
+        if (!invoice?.id)
+            continue;
+        const amountPaidCents = numberOrUndefined(invoice.amount_paid);
+        if (amountPaidCents === undefined || amountPaidCents <= 0)
+            continue;
+        // customer is the expanded object when expand[]=data.customer was honored,
+        // else the plain id string — handle both.
+        const customer = invoice.customer;
+        const customerId = typeof customer === "string" ? customer : stringOrUndefined(customer?.id);
+        // Invoices also carry flat customer_name/customer_email copies — use them
+        // when the customer object wasn't expanded (or lacks the field).
+        const customerName = (typeof customer === "object" && customer !== null
+            ? stringOrUndefined(customer.name)
+            : undefined) ?? stringOrUndefined(invoice.customer_name);
+        const customerEmail = typeof customer === "object" && customer !== null
+            ? stringOrUndefined(customer.email) ?? stringOrUndefined(invoice.customer_email)
+            : stringOrUndefined(invoice.customer_email);
+        const customerDomain = customerEmail?.includes("@")
+            ? customerEmail.split("@").at(-1).toLowerCase()
+            : undefined;
+        const paidAtSeconds = numberOrUndefined(invoice.status_transitions?.paid_at);
+        paid.push({
+            id: String(invoice.id),
+            number: stringOrUndefined(invoice.number),
+            customerId,
+            customerName,
+            customerEmail,
+            customerDomain,
+            amountPaid: amountPaidCents / 100,
+            currency: stringOrUndefined(invoice.currency)?.toUpperCase(),
+            paidAt: paidAtSeconds !== undefined
+                ? new Date(paidAtSeconds * 1000).toISOString().split("T")[0]
+                : undefined,
+            description: stringOrUndefined(invoice.description),
+        });
+    }
+    return paid;
+}
 function stringOrUndefined(value) {
     if (value === undefined || value === null || value === "")
         return undefined;

package/dist/enrich.d.ts

@@ -1,4 +1,5 @@
 import type { AcquireBudget } from "./acquireMeter.ts";
+import type { ProgressEmitter } from "./progress.ts";
 import type { AssignmentContext, AssignmentPolicy } from "./assign.ts";
 import type { CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
 /**
@@ -250,6 +251,12 @@ export type BuildAcquirePlanOptions = {
     /** Meter ceiling: max create ops to emit. null/undefined = unlimited. */
     maxRecords?: number | null;
     now?: () => Date;
+    /**
+     * Shared progress vocabulary (src/progress.ts): `items` over the candidate
+     * rows as they are routed, plus a `meter` reading of creates vs the meter
+     * ceiling. Presentation-only — never changes what the plan proposes.
+     */
+    progress?: ProgressEmitter;
 };
 /**
  * Lift a prospect/source payload into the routing attributes a territory rule

package/dist/enrich.js

@@ -816,7 +816,10 @@ export function buildAcquirePlan(options) {
             }
         }
     }
+    let routed = 0;
     for (const record of records) {
+        // Progress heartbeat over the candidate rows (throttled by the emitter).
+        options.progress?.items((routed += 1), records.length);
         const createMap = acquire.create[record.objectType];
         const match = config.match[record.objectType];
         // No create mapping or no match config for this type — can neither create
@@ -923,6 +926,10 @@ export function buildAcquirePlan(options) {
         counts.created += 1;
         estCostUsd += costPerRecord;
     }
+    options.progress?.flush();
+    // Meter reading: creates proposed this run against the meter's ceiling.
+    if (cap !== null)
+        options.progress?.meter(counts.created, cap, "creates");
     const plan = {
         id: `patch_plan_acq_${fnv1a(`${source}:${runLabel}:${nowIso}`)}`,
         title: `Acquire leads — ${source}`,

package/dist/health.d.ts

@@ -1,74 +1,16 @@
-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;
-    }>;
-};
+import type { CanonicalGtmSnapshot } from "./types.ts";
+import type { HealthEntry } from "./healthScore.ts";
+export { computeHealth, summarizeHealth, healthToMarkdown, type HealthEntry, type HealthRuleDelta, type HealthRollup, } from "./healthScore.ts";
 /**
- * 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.
+ * The engagement workspace: a per-client health timeline that accrues from the
+ * verb people already run (`audit --save`). State lives in the profile dir
+ * (`$FSGTM_HOME[/profiles/<name>]`) alongside credentials and plans, so a
+ * consultant working `--profile <client>` builds a continuous record of one
+ * org's CRM health over time — not just episodic one-off audits.
+ *
+ * The score is DETERMINISTIC (no LLM): same plan + same snapshot → same score,
+ * so it is stable in CI and comparable run-over-run.
  */
-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;
 /** `$FSGTM_HOME[/profiles/<name>]/health.jsonl` — append-only, one entry per audit-save. */
 export declare function healthFilePath(): string;
 /** `$FSGTM_HOME[/profiles/<name>]/snapshots/` — canonical snapshots correlated by plan id. */