fullstackgtm 0.41.0 → 0.43.0

package/dist/connectors/salesforce.js

@@ -37,29 +37,53 @@ export function createSalesforceConnector(options) {
     // confirmed miss is created, and an ambiguous name (>1 match) is refused.
     // Caches within the run so the same name is never created twice — shared by
     // `link_record`'s create:<Name> path and `create_record`'s company linking.
-    async function resolveOrCreateAccountByName(name) {
-        const nameKey = name.toLowerCase();
-        const cached = createdAccountsByName.get(nameKey);
+    async function resolveOrCreateAccount(name, domain) {
+        const cacheKey = domain ? `d:${domain.toLowerCase()}` : `n:${name.toLowerCase()}`;
+        const cached = createdAccountsByName.get(cacheKey);
         if (cached)
             return { id: cached, createdNew: false };
-        const soqlName = name.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-        const matches = await query(`SELECT Id FROM Account WHERE Name = '${soqlName}' LIMIT 3`);
-        if (matches.length > 1)
-            return { ambiguous: matches.length };
+        const esc = (v) => v.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+        // 1. Domain-first match on Website (the accurate key; Website often stores a
+        //    full URL, so match by substring).
+        if (domain) {
+            const byDomain = await query(`SELECT Id FROM Account WHERE Website LIKE '%${esc(domain)}%' LIMIT 3`);
+            if (byDomain.length > 1)
+                return { ambiguous: byDomain.length };
+            if (byDomain.length === 1) {
+                const id = String(byDomain[0].Id);
+                createdAccountsByName.set(cacheKey, id);
+                return { id, createdNew: false };
+            }
+        }
+        // 2. Exact-name match; stamp Website if the account has none (fill-blank).
+        const byName = await query(`SELECT Id, Website FROM Account WHERE Name = '${esc(name)}' LIMIT 3`);
+        if (byName.length > 1)
+            return { ambiguous: byName.length };
         let id;
         let createdNew = false;
-        if (matches.length === 1) {
-            id = String(matches[0].Id);
+        if (byName.length === 1) {
+            id = String(byName[0].Id);
+            if (domain && !stringOrUndefined(byName[0].Website)) {
+                try {
+                    await request(`/services/data/${apiVersion}/sobjects/Account/${encodeURIComponent(id)}`, {
+                        method: "PATCH",
+                        body: JSON.stringify({ Website: domain }),
+                    });
+                }
+                catch {
+                    // best-effort fill — a failed Website stamp must not sink the create.
+                }
+            }
         }
         else {
             const created = await request(`/services/data/${apiVersion}/sobjects/Account`, {
                 method: "POST",
-                body: JSON.stringify({ Name: name }),
+                body: JSON.stringify({ Name: name, ...(domain ? { Website: domain } : {}) }),
             });
             id = String(created.id);
             createdNew = true;
         }
-        createdAccountsByName.set(nameKey, id);
+        createdAccountsByName.set(cacheKey, id);
         return { id, createdNew };
     }
     async function request(path, init = {}) {
@@ -427,7 +451,7 @@ export function createSalesforceConnector(options) {
             return { operationId: operation.id, status: "skipped", detail: "create_record needs a non-empty matchValue to resolve-first." };
         }
         if (operation.objectType === "account") {
-            const resolved = await resolveOrCreateAccountByName(matchValue);
+            const resolved = await resolveOrCreateAccount(matchValue);
             if ("ambiguous" in resolved) {
                 return { operationId: operation.id, status: "skipped", detail: `create_record: ambiguous — ${resolved.ambiguous} accounts named "${matchValue}". Not creating.` };
             }
@@ -465,7 +489,7 @@ export function createSalesforceConnector(options) {
         let companyNote = "";
         if (payload.associateCompanyName) {
             try {
-                const resolved = await resolveOrCreateAccountByName(payload.associateCompanyName);
+                const resolved = await resolveOrCreateAccount(payload.associateCompanyName, payload.associateCompanyDomain);
                 if ("ambiguous" in resolved) {
                     companyNote = ` Account "${payload.associateCompanyName}" was ambiguous; left unlinked.`;
                 }
@@ -474,7 +498,8 @@ export function createSalesforceConnector(options) {
                         method: "PATCH",
                         body: JSON.stringify({ AccountId: resolved.id }),
                     });
-                    companyNote = ` Linked to account "${payload.associateCompanyName}" (${resolved.id}).`;
+                    const domainNote = payload.associateCompanyDomain ? ` (${payload.associateCompanyDomain})` : "";
+                    companyNote = ` Linked to account "${payload.associateCompanyName}"${domainNote} (${resolved.id}).`;
                 }
             }
             catch (error) {
@@ -489,6 +514,117 @@ export function createSalesforceConnector(options) {
             providerData: { id: contactId, created: true },
         };
     }
+    /**
+     * Batch create_record for contacts: bulk resolve-first (SOQL IN), then create
+     * the misses via the Composite sObject Collections API (allOrNone:false,
+     * 200/call), instead of two round-trips per lead. A record-level failure in
+     * the collection (e.g. a duplicate rule) falls back to per-record createRecord
+     * so one bad row never sinks the rest. Returns one result per input op.
+     */
+    async function applyCreateContactsBatch(operations) {
+        const byId = new Map();
+        const groups = new Map();
+        for (const op of operations) {
+            const matchKey = op.afterValue?.matchKey || "email";
+            const searchField = mappedField(mappings, "contacts", matchKey, SALESFORCE_DEFAULT_FIELD_MAPPINGS.contacts[matchKey] ?? matchKey);
+            let arr = groups.get(searchField);
+            if (!arr)
+                groups.set(searchField, (arr = []));
+            arr.push(op);
+        }
+        for (const [searchField, ops] of groups) {
+            // 1. Bulk resolve-first via SOQL IN (chunked; values SOQL-escaped).
+            const existing = new Map();
+            const uniqueValues = [
+                ...new Set(ops.map((op) => String(op.afterValue.matchValue ?? "").trim()).filter(Boolean)),
+            ];
+            for (let i = 0; i < uniqueValues.length; i += 200) {
+                const inList = uniqueValues
+                    .slice(i, i + 200)
+                    .map((v) => `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`)
+                    .join(",");
+                const rows = await query(`SELECT Id, ${searchField} FROM Contact WHERE ${searchField} IN (${inList})`);
+                for (const row of rows) {
+                    const v = row?.[searchField];
+                    if (typeof v === "string" && row.Id)
+                        existing.set(v.toLowerCase(), String(row.Id));
+                }
+            }
+            // 2. Partition: existing / already-this-run / dup-in-batch / to-create.
+            const toCreate = [];
+            const seenInBatch = new Set();
+            for (const op of ops) {
+                const payload = op.afterValue;
+                const matchKey = payload.matchKey || "email";
+                const matchValue = String(payload.matchValue ?? "").trim();
+                if (!matchValue) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: "create_record needs a non-empty matchValue to resolve-first." });
+                    continue;
+                }
+                const lower = matchValue.toLowerCase();
+                const dedupeKey = `${matchKey}:${lower}`;
+                const already = createdContactsByMatch.get(dedupeKey);
+                if (already) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} already created earlier in this run; not duplicating.`, providerData: { id: already, existing: true } });
+                    continue;
+                }
+                const existingId = existing.get(lower);
+                if (existingId) {
+                    createdContactsByMatch.set(dedupeKey, existingId);
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} already exists (${existingId}); resolve-first declined to create.`, providerData: { id: existingId, existing: true } });
+                    continue;
+                }
+                if (seenInBatch.has(lower)) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} duplicated within this batch; not duplicating.` });
+                    continue;
+                }
+                seenInBatch.add(lower);
+                toCreate.push(op);
+            }
+            // 3. Bulk create via Composite sObject Collections (allOrNone:false →
+            //    per-record results in request order).
+            for (let i = 0; i < toCreate.length; i += 200) {
+                const chunk = toCreate.slice(i, i + 200);
+                const records = chunk.map((op) => {
+                    const payload = op.afterValue;
+                    const fields = { ...payload.properties };
+                    if (payload.ownerId) {
+                        const ownerField = mappedField(mappings, "contacts", "ownerId", SALESFORCE_DEFAULT_FIELD_MAPPINGS.contacts.ownerId ?? "OwnerId");
+                        if (!fields[ownerField])
+                            fields[ownerField] = String(payload.ownerId);
+                    }
+                    return { attributes: { type: "Contact" }, ...fields };
+                });
+                let results;
+                try {
+                    results = (await request(`/services/data/${apiVersion}/composite/sobjects`, {
+                        method: "POST",
+                        body: JSON.stringify({ allOrNone: false, records }),
+                    }));
+                }
+                catch {
+                    for (const op of chunk)
+                        byId.set(op.id, await createRecord(op));
+                    continue;
+                }
+                for (let j = 0; j < chunk.length; j++) {
+                    const op = chunk[j];
+                    const res = Array.isArray(results) ? results[j] : undefined;
+                    const payload = op.afterValue;
+                    const matchKey = payload.matchKey || "email";
+                    const matchValue = String(payload.matchValue).trim();
+                    if (res?.success && res.id) {
+                        createdContactsByMatch.set(`${matchKey}:${matchValue.toLowerCase()}`, String(res.id));
+                        byId.set(op.id, { operationId: op.id, status: "applied", detail: `Created contact ${matchKey}=${matchValue} (${res.id}).`, providerData: { id: String(res.id), created: true } });
+                    }
+                    else {
+                        byId.set(op.id, await createRecord(op)); // record-level failure → isolate per record
+                    }
+                }
+            }
+        }
+        return operations.map((op) => byId.get(op.id) ?? { operationId: op.id, status: "skipped", detail: "create_record was not processed." });
+    }
     async function applyOperation(operation) {
         try {
             switch (operation.operation) {
@@ -506,7 +642,7 @@ export function createSalesforceConnector(options) {
                         if (!name) {
                             return { operationId: operation.id, status: "skipped", detail: "create: needs an account name (create:<Name>)." };
                         }
-                        const resolved = await resolveOrCreateAccountByName(name);
+                        const resolved = await resolveOrCreateAccount(name);
                         if ("ambiguous" in resolved) {
                             return {
                                 operationId: operation.id,
@@ -568,6 +704,7 @@ export function createSalesforceConnector(options) {
         fetchSnapshot,
         fetchChanges,
         applyOperation,
+        applyCreateContactsBatch,
         readField,
     };
 }

package/dist/draft.js

@@ -197,9 +197,6 @@ export function draft(opts) {
     const minScore = opts.minScore ?? 80;
     const channel = opts.channel ?? "task";
     const freshnessDays = opts.freshnessDays ?? DEFAULT_FRESHNESS_DAYS;
-    // `task`/`email`/`linkedin` all write a CRM task through the same gate; the
-    // object the task hangs off is the contact when known, else the account.
-    const objectType = "contact";
     const hot = opts.decisions
         .filter((d) => d.decision === "send" && d.score >= minScore)
         .sort((a, b) => b.score - a.score || a.accountDomain.localeCompare(b.accountDomain));
@@ -235,17 +232,42 @@ export function draft(opts) {
             });
             continue;
         }
+        // Resolve a REAL CRM target from the judge decision: a contact id (preferred
+        // — that's who we message), else the account id. A domain-only decision
+        // (the account isn't in the CRM yet) cannot hang a task off a record — reject
+        // it with the fix, instead of forging a contact-typed op carrying a domain.
+        let objectType;
+        let objectId;
+        let targetNote;
+        if (decision.contact?.id) {
+            objectType = "contact";
+            objectId = decision.contact.id;
+            targetNote = `contact ${decision.contact.email ?? decision.contact.id}`;
+        }
+        else if (decision.accountId) {
+            objectType = "account";
+            objectId = decision.accountId;
+            targetNote = `account ${domain}`;
+        }
+        else {
+            rejected.push({
+                accountDomain: domain,
+                opener,
+                reason: `account ${domain} is not in the CRM — acquire it first (enrich acquire), then judge with a snapshot, before drafting`,
+            });
+            continue;
+        }
         const stale = isStaleTrigger(signal.firstSeen, now, freshnessDays);
         const ev = draftEvidence(signal, nowIso);
         evidence.push(ev);
-        const reasonBase = `Signal-grounded opener for ${domain}: "${signal.trigger}"`;
+        const reasonBase = `Signal-grounded opener for ${domain} → ${targetNote}: "${signal.trigger}"`;
         const reason = stale
             ? `${reasonBase} [staleTrigger: grounding signal first seen ${signal.firstSeen}, older than ${freshnessDays}d — could this have gone out last month unchanged?]`
             : reasonBase;
         operations.push({
             id: draftOperationId(channel, domain),
             objectType,
-            objectId: domain,
+            objectId,
             operation: "create_task",
             field: "follow_up_task",
             beforeValue: null,

package/dist/enrich.d.ts

@@ -68,6 +68,12 @@ export type AcquireCreateMap = {
     matchKey: string;
     /** Optional source path to a company name; the connector resolves-or-creates it. */
     associateCompanyFrom?: string;
+    /**
+     * Optional source path to the company domain. With it (or a derivable email
+     * domain) the connector resolves the account by domain and stamps the domain
+     * on it — so the lead's account is signal-watchable, not just a text field.
+     */
+    associateCompanyDomainFrom?: string;
 };
 /**
  * Net-new discovery for an API acquire source. `provider` selects the adapter

package/dist/enrich.js

@@ -247,6 +247,8 @@ export function builtinAcquirePreset(source) {
                             company: "companyName",
                             email: "email",
                         },
+                        associateCompanyFrom: "companyName",
+                        associateCompanyDomainFrom: "companyDomain",
                     },
                 },
             },
@@ -274,6 +276,8 @@ export function builtinAcquirePreset(source) {
                         company: "companyName",
                         hs_linkedin_url: "linkedin",
                     },
+                    associateCompanyFrom: "companyName",
+                    associateCompanyDomainFrom: "companyDomain",
                 },
             },
         },
@@ -490,6 +494,28 @@ function crmFieldValue(snapshot, objectType, objectId, field) {
 function isEmptyValue(value) {
     return value === undefined || value === null || (typeof value === "string" && value.trim() === "");
 }
+/** Bare registrable host from a domain or URL ("https://www.x.com/a" → "x.com"). */
+function normalizeCompanyDomain(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const host = value
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .replace(/\/.*$/, "")
+        .replace(/\s+/g, "");
+    return host && host.includes(".") ? host : undefined;
+}
+/** The domain of a work email ("vp@acme.com" → "acme.com"), else undefined. */
+function domainFromEmail(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const at = value.lastIndexOf("@");
+    if (at < 0)
+        return undefined;
+    return normalizeCompanyDomain(value.slice(at + 1));
+}
 /** Values compare as trimmed strings; numbers compare numerically. */
 function sameValue(a, b) {
     if (isEmptyValue(a) && isEmptyValue(b))
@@ -831,6 +857,21 @@ export function buildAcquirePlan(options) {
             if (!isEmptyValue(companyValue))
                 associateCompanyName = String(companyValue);
         }
+        // The company domain makes the lead's account signal-watchable. Prefer the
+        // configured source path; fall back to the work email's domain (free, and
+        // for B2B leads the email domain IS the company domain).
+        let associateCompanyDomain;
+        if (associateCompanyName) {
+            const fromPath = createMap.associateCompanyDomainFrom
+                ? sourceValueAt(record.payload, createMap.associateCompanyDomainFrom)
+                : undefined;
+            const candidate = !isEmptyValue(fromPath)
+                ? String(fromPath)
+                : domainFromEmail(sourceValueAt(record.payload, "email"));
+            const normalized = normalizeCompanyDomain(candidate);
+            if (normalized)
+                associateCompanyDomain = normalized;
+        }
         const recordEvidence = evidenceFor(source, sourceConfig.kind, sourceConfig.format, record, undefined, nowIso);
         evidence.push(recordEvidence);
         // Resolve ownership BEFORE the meter-charged create lands, so the lead is
@@ -853,8 +894,13 @@ export function buildAcquirePlan(options) {
             source,
             estCostUsd: costPerRecord,
             associateCompanyName,
+            ...(associateCompanyDomain ? { associateCompanyDomain } : {}),
             ...(ownerId ? { ownerId, assignedBy } : {}),
         };
+        // Surface the account link in the dry-run so it is not a silent side-effect.
+        const accountNote = associateCompanyName
+            ? ` Resolves/creates its account "${associateCompanyName}"${associateCompanyDomain ? ` (${associateCompanyDomain})` : ""} and links the lead.`
+            : "";
         operations.push({
             id: `op_acq_${fnv1a(`${source}:${record.objectType}:${matchValue}`)}`,
             objectType: canonicalObjectType(record.objectType),
@@ -863,7 +909,7 @@ export function buildAcquirePlan(options) {
             beforeValue: null,
             afterValue: payload,
             reason: `${source} sourced net-new ${record.objectType} "${describeSourceRecord(record)}" ` +
-                `(${createMap.matchKey}=${matchValue}); no CRM match — create as a lead.`,
+                `(${createMap.matchKey}=${matchValue}); no CRM match — create as a lead.${accountNote}`,
             sourceRuleOrPolicy: `acquire:${source}`,
             riskLevel: "medium",
             approvalRequired: true,

package/dist/health.d.ts

@@ -21,6 +21,18 @@ export type HealthEntry = {
     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;

package/dist/health.js

@@ -23,11 +23,21 @@ const SEVERITY_WEIGHT = { info: 1, warning: 3, critical: 10 };
 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,
@@ -35,8 +45,18 @@ export function computeHealth(plan, snapshot, at) {
         deals: snapshot.deals.length,
         total: snapshot.accounts.length + snapshot.contacts.length + snapshot.deals.length,
     };
-    const penalty = weightedFindings / Math.max(records.total, 1);
-    const score = Math.round(100 / (1 + penalty));
+    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,
@@ -46,6 +66,7 @@ export function computeHealth(plan, snapshot, at) {
         records,
         byRule,
         severityCounts,
+        byObjectType,
     };
 }
 /** Roll a timeline up into the current state, the change since last time, and per-rule deltas. */
@@ -95,6 +116,12 @@ export function healthToMarkdown(rollup) {
         ? "(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) {

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { createStripeConnector, type StripeConnectorOptions } from "./connectors
 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";
+export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, type InitProvider, type InitSource, type ScaffoldFile, type ScaffoldOptions, } from "./init.ts";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, type ApolloClient, type ApolloClientOptions, type ApolloPullKey, type ApolloPullResult, } from "./enrichApollo.ts";
 export { diffFindings, diffSnapshots, diffToMarkdown, type CollectionDiff, type FieldChange, type FindingsDrift, type RecordChange, type SnapshotDiff, } from "./diff.ts";
 export { mergeSnapshots, type MergeConflict, type MergeMatch, type MergeReport, type MergeSuggestion, } from "./merge.ts";

package/dist/index.js

@@ -13,6 +13,7 @@ export { createStripeConnector } from "./connectors/stripe.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";
+export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, } from "./init.js";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, } from "./enrichApollo.js";
 export { diffFindings, diffSnapshots, diffToMarkdown, } from "./diff.js";
 export { mergeSnapshots, } from "./merge.js";

package/dist/init.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `fullstackgtm init` — scaffold a GTM workspace from cold scratch.
+ *
+ * The product thesis (see docs/recipes.md): the CLI ships governed PRIMITIVES;
+ * the user's coding agent is the orchestrator. There is deliberately no
+ * `outbound` mega-verb. `init` is the one piece of scaffolding that earns its
+ * keep — it writes the three files a workspace needs so the very first
+ * `enrich acquire` / `signals` / `judge` / `draft` commands work, plus a
+ * PLAYBOOK that points at the recipes wired with THIS workspace's source and
+ * provider.
+ *
+ * It is a pure file-writer: no network, no credentials, never overwrites
+ * without `--force`. The starter ICP is a valid (editable) example so
+ * `icp show` / `enrich acquire` run immediately; re-run `icp interview` to
+ * replace it with a real one.
+ */
+import { type EnrichConfig } from "./enrich.ts";
+import { type Icp } from "./icp.ts";
+export type InitProvider = "hubspot" | "salesforce";
+export type InitSource = "pipe0" | "explorium" | "linkedin";
+export type ScaffoldOptions = {
+    /** discovery source the acquire preset + playbook are wired for. Default "pipe0". */
+    source?: InitSource;
+    /** CRM the playbook writes against. Default "hubspot". */
+    provider?: InitProvider;
+    /** profile the playbook scopes commands to (omitted = default profile). */
+    profile?: string;
+};
+export type ScaffoldFile = {
+    path: string;
+    content: string;
+};
+/** A generic, valid starter ICP. Edit it, or replace via `icp interview`. */
+export declare function starterIcp(): Icp;
+/** The acquire preset for the chosen source, with an explicit (placeholder)
+ *  assign policy so the seam is visible — leads are never silently ownerless. */
+export declare function starterEnrichConfig(source: InitSource): EnrichConfig;
+/** The workspace PLAYBOOK: the cold-start + outbound-loop recipes wired with the
+ *  chosen source/provider/profile, pointing at docs/recipes.md for the rest. */
+export declare function starterPlaybook(opts: Required<Pick<ScaffoldOptions, "source" | "provider">> & {
+    profile?: string;
+}): string;
+/**
+ * Build the set of files `init` would write (pure — no IO). The caller decides
+ * which to actually write (skipping existing files unless --force).
+ */
+export declare function scaffoldWorkspace(opts?: ScaffoldOptions): ScaffoldFile[];