fullstackgtm 0.42.0 → 0.44.0

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/icp.d.ts

@@ -23,6 +23,10 @@ export type Icp = {
         employeeBands?: string[];
         /** ISO country codes, lowercased, e.g. ["us"] */
         geos?: string[];
+        /** technographic targeting: technology slugs the account must use, e.g.
+         *  ["salesforce","hubspot","pipedrive"] — the real CRM/MAP buying signal,
+         *  consumed by TheirStack company search. OR-matched. */
+        technologies?: string[];
     };
     persona: {
         /** seniority: "cxo","vp","director","manager","owner","senior" */
@@ -47,13 +51,53 @@ export declare function icpToExploriumFilters(icp: Icp): Record<string, {
     values?: string[];
     value?: boolean;
 }>;
+/**
+ * Explorium /v1/businesses filters from the ICP — the COMPANY (account) side, for
+ * sizing the account universe (TAM). Firmographics only, no persona: the count is
+ * of matching companies. Field names differ from /v1/prospects (verified live):
+ * `country_code` (not company_country_code), `company_size` (same employee bands),
+ * `naics_category`. `/v1/businesses` total_results is a real count, capped at
+ * 60,000 (see EXPLORIUM_BUSINESS_COUNT_CAP in the connector).
+ */
+export declare function icpToExploriumBusinessFilters(icp: Icp): Record<string, {
+    values?: string[];
+}>;
+/**
+ * Collapse provider-agnostic employee bands ("51-200","10001+") into a single
+ * {min,max} envelope for APIs that take integer bounds (TheirStack). An open
+ * top band ("10001+") leaves max undefined.
+ */
+export declare function employeeBandsToRange(bands: string[] | undefined): {
+    min?: number;
+    max?: number;
+};
+/**
+ * TheirStack company-search filter from the ICP: the technographic targeting that
+ * Explorium can't do. `company_technology_slug_or` is the CRM/MAP buying signal
+ * (firmographics.technologies); employee bands become min/max bounds; geos become
+ * ISO2 codes (uppercased).
+ */
+export declare function icpToTheirStackFilters(icp: Icp): {
+    company_technology_slug_or?: string[];
+    min_employee_count?: number;
+    max_employee_count?: number;
+    company_country_code_or?: string[];
+};
 /**
  * pipe0 Crustdata people-search config.filters from the ICP. `current_job_titles`
  * matches real LinkedIn title strings (case-sensitive), so keywords are Title
  * Cased. Seniority + industry are mapped to Crustdata's controlled vocab via the
- * tables above. NOTE: the exact pipe0→Crustdata value set could not be re-run
- * live (pipe0 credits were exhausted) — validate when credits refill; fit
- * scoring is the safety net for persona precision regardless.
+ * tables above.
+ *
+ * LIVE FINDINGS (2026-06-26): `current_job_titles` is confirmed working (a
+ * titles-only RevOps search returns results); `current_title` is rejected (422).
+ * The full ICP filter returned 0 — the prime suspect is the industry vocab
+ * (LinkedIn v1/v2 taxonomy mismatch), now hedged by sending BOTH generations in
+ * CRUSTDATA_INDUSTRY above. NOT yet re-confirmed end-to-end (pipe0 credits were
+ * exhausted mid-investigation) — re-run `enrich acquire --source pipe0` once
+ * credits refill; if it still returns 0, the next suspects are the
+ * `current_seniority_levels` shape/values and `locations`. Note fit-scoring backs
+ * up PERSONA precision but NOT industry, so the industry filter is load-bearing.
  */
 export declare function icpToCrustdataFilters(icp: Icp): Record<string, unknown>;
 export type IcpFit = {

package/dist/icp.js

@@ -54,6 +54,77 @@ export function icpToExploriumFilters(icp) {
         f.naics_category = { values: icp.firmographics.naics };
     return f;
 }
+/**
+ * Explorium /v1/businesses filters from the ICP — the COMPANY (account) side, for
+ * sizing the account universe (TAM). Firmographics only, no persona: the count is
+ * of matching companies. Field names differ from /v1/prospects (verified live):
+ * `country_code` (not company_country_code), `company_size` (same employee bands),
+ * `naics_category`. `/v1/businesses` total_results is a real count, capped at
+ * 60,000 (see EXPLORIUM_BUSINESS_COUNT_CAP in the connector).
+ */
+export function icpToExploriumBusinessFilters(icp) {
+    const f = {};
+    if (icp.firmographics.geos?.length)
+        f.country_code = { values: icp.firmographics.geos };
+    if (icp.firmographics.employeeBands?.length)
+        f.company_size = { values: icp.firmographics.employeeBands };
+    if (icp.firmographics.naics?.length)
+        f.naics_category = { values: icp.firmographics.naics };
+    return f;
+}
+/**
+ * Collapse provider-agnostic employee bands ("51-200","10001+") into a single
+ * {min,max} envelope for APIs that take integer bounds (TheirStack). An open
+ * top band ("10001+") leaves max undefined.
+ */
+export function employeeBandsToRange(bands) {
+    if (!bands?.length)
+        return {};
+    let min;
+    let max;
+    let openTop = false;
+    for (const band of bands) {
+        const plus = /^(\d+)\+$/.exec(band.trim());
+        if (plus) {
+            const lo = Number(plus[1]);
+            if (min === undefined || lo < min)
+                min = lo;
+            openTop = true;
+            continue;
+        }
+        const range = /^(\d+)\s*-\s*(\d+)$/.exec(band.trim());
+        if (range) {
+            const lo = Number(range[1]);
+            const hi = Number(range[2]);
+            if (min === undefined || lo < min)
+                min = lo;
+            if (max === undefined || hi > max)
+                max = hi;
+        }
+    }
+    return { min, max: openTop ? undefined : max };
+}
+/**
+ * TheirStack company-search filter from the ICP: the technographic targeting that
+ * Explorium can't do. `company_technology_slug_or` is the CRM/MAP buying signal
+ * (firmographics.technologies); employee bands become min/max bounds; geos become
+ * ISO2 codes (uppercased).
+ */
+export function icpToTheirStackFilters(icp) {
+    const f = {};
+    if (icp.firmographics.technologies?.length) {
+        f.company_technology_slug_or = icp.firmographics.technologies.map((t) => t.trim().toLowerCase());
+    }
+    if (icp.firmographics.geos?.length) {
+        f.company_country_code_or = icp.firmographics.geos.map((g) => g.trim().toUpperCase());
+    }
+    const range = employeeBandsToRange(icp.firmographics.employeeBands);
+    if (range.min !== undefined)
+        f.min_employee_count = range.min;
+    if (range.max !== undefined)
+        f.max_employee_count = range.max;
+    return f;
+}
 /**
  * Crustdata / LinkedIn seniority vocab. ICP job levels are normalized lowercase;
  * Crustdata expects these exact capitalized strings (verified: "CXO",
@@ -75,16 +146,31 @@ const CRUSTDATA_SENIORITY = {
     entry: "Entry",
 };
 /**
- * ICP industry keyword → LinkedIn industry names Crustdata filters on. Includes
- * the current LinkedIn-v2 names; for software we send the cluster (dev + IT
- * services + internet) so an OR match isn't overly narrow.
+ * ICP industry keyword → LinkedIn industry names Crustdata filters on.
+ *
+ * LinkedIn renamed its industry taxonomy (v1 → v2, ~2022), and data vendors
+ * normalize to one generation or the other. Sending ONLY the v2 names risks a
+ * zero-match when Crustdata stores v1 (and vice-versa) — observed live: a RevOps
+ * ICP whose only firmographic constraint was the v2 names returned 0 even though
+ * the title-only search returned plenty. So each cluster sends BOTH generations
+ * (OR-matched within the field): v2 ("Software Development", "IT Services and IT
+ * Consulting", "Technology, Information and Internet") AND v1 ("Computer
+ * Software", "Information Technology & Services", "Internet").
  */
 const CRUSTDATA_INDUSTRY = {
-    software: ["Software Development", "Information Technology and Services", "Internet"],
-    saas: ["Software Development", "Information Technology and Services"],
-    "information technology & services": ["Information Technology and Services"],
-    "information technology and services": ["Information Technology and Services"],
-    internet: ["Internet"],
+    software: [
+        "Software Development",
+        "Computer Software",
+        "IT Services and IT Consulting",
+        "Information Technology & Services",
+        "Information Technology and Services",
+        "Technology, Information and Internet",
+        "Internet",
+    ],
+    saas: ["Software Development", "Computer Software", "IT Services and IT Consulting", "Information Technology & Services"],
+    "information technology & services": ["Information Technology & Services", "IT Services and IT Consulting"],
+    "information technology and services": ["Information Technology & Services", "IT Services and IT Consulting"],
+    internet: ["Internet", "Technology, Information and Internet"],
     fintech: ["Financial Services"],
     "financial services": ["Financial Services"],
 };
@@ -92,9 +178,17 @@ const CRUSTDATA_INDUSTRY = {
  * pipe0 Crustdata people-search config.filters from the ICP. `current_job_titles`
  * matches real LinkedIn title strings (case-sensitive), so keywords are Title
  * Cased. Seniority + industry are mapped to Crustdata's controlled vocab via the
- * tables above. NOTE: the exact pipe0→Crustdata value set could not be re-run
- * live (pipe0 credits were exhausted) — validate when credits refill; fit
- * scoring is the safety net for persona precision regardless.
+ * tables above.
+ *
+ * LIVE FINDINGS (2026-06-26): `current_job_titles` is confirmed working (a
+ * titles-only RevOps search returns results); `current_title` is rejected (422).
+ * The full ICP filter returned 0 — the prime suspect is the industry vocab
+ * (LinkedIn v1/v2 taxonomy mismatch), now hedged by sending BOTH generations in
+ * CRUSTDATA_INDUSTRY above. NOT yet re-confirmed end-to-end (pipe0 credits were
+ * exhausted mid-investigation) — re-run `enrich acquire --source pipe0` once
+ * credits refill; if it still returns 0, the next suspects are the
+ * `current_seniority_levels` shape/values and `locations`. Note fit-scoring backs
+ * up PERSONA precision but NOT industry, so the industry filter is load-bearing.
  */
 export function icpToCrustdataFilters(icp) {
     const f = {};

package/dist/index.d.ts

@@ -13,6 +13,8 @@ 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 { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, type AccountTamClass, type AcvBasis, type DerivedAcv, type DerivedBuyers, type EstimateTamInput, type TamClassified, type TamCoverage, type TamCoverageCounts, type TamCrossCheck, type TamEta, type TamModel, type TamTargeting, type TamUniverse, } from "./tam.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,8 @@ 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 { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, } from "./tam.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[];

package/dist/init.js

@@ -0,0 +1,143 @@
+/**
+ * `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 { builtinAcquirePreset, ENRICH_CONFIG_FILE_NAME } from "./enrich.js";
+import { DEFAULT_FIT_THRESHOLD } from "./icp.js";
+/** A placeholder owner id that can never match a real one, so the assign block
+ *  is VISIBLE (leads route through it) yet safe: an unknown owner resolves to
+ *  unassigned with a warning, never a wrong owner. Replace before acquiring. */
+const PLACEHOLDER_OWNER = "REPLACE_WITH_OWNER_ID";
+/** A generic, valid starter ICP. Edit it, or replace via `icp interview`. */
+export function starterIcp() {
+    return {
+        name: "Example ICP — edit me (or rebuild with `fullstackgtm icp interview`)",
+        firmographics: {
+            industries: ["software", "saas"],
+            employeeBands: ["51-200", "201-500", "501-1000"],
+            geos: ["us"],
+            // Technographic targeting (the real RevOps signal): companies that USE a
+            // CRM/MAP. Drives `tam estimate|accounts --source theirstack`.
+            technologies: ["salesforce", "hubspot", "pipedrive"],
+        },
+        persona: {
+            jobLevels: ["vp", "director", "manager"],
+            departments: ["sales", "operations"],
+            titleKeywords: ["revenue operations", "revops", "sales operations", "gtm operations"],
+        },
+        scoring: { threshold: DEFAULT_FIT_THRESHOLD },
+    };
+}
+/** The acquire preset for the chosen source, with an explicit (placeholder)
+ *  assign policy so the seam is visible — leads are never silently ownerless. */
+export function starterEnrichConfig(source) {
+    const preset = builtinAcquirePreset(source);
+    if (!preset?.acquire) {
+        // builtinAcquirePreset covers pipe0/explorium/linkedin, so this is unreachable
+        // for the typed InitSource set — guard anyway rather than emit a broken file.
+        throw new Error(`init: no acquire preset for source "${source}"`);
+    }
+    return {
+        ...preset,
+        acquire: { ...preset.acquire, assign: { strategy: "fixed", ownerId: PLACEHOLDER_OWNER } },
+    };
+}
+function profileFlag(profile) {
+    return profile ? ` --profile ${profile}` : "";
+}
+/** 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 function starterPlaybook(opts) {
+    const { source, provider, profile } = opts;
+    const p = profileFlag(profile);
+    const loginSource = source === "linkedin" ? "heyreach" : source;
+    return `# Workspace playbook
+
+Scaffolded by \`fullstackgtm init\` for **${provider}**, discovery via **${source}**${profile ? `, profile **${profile}**` : ""}.
+
+This CLI ships governed **primitives** — there is no \`outbound\` command. **You
+(the coding agent) are the orchestrator:** chain the verbs into the play the
+operator wants, surface the one approve gate, and bridge the last mile to the
+sender. **The package never sends** — \`draft\` produces an approved task/opener;
+the actual send happens in the operator's own channel tool.
+
+Full recipe set: **docs/recipes.md** (cold-start, the trigger→judge→draft
+outbound loop, scheduled-continuous, ABM-from-companies, hygiene-gated).
+
+## 0. Connect (secrets via stdin/env, never argv)
+
+\`\`\`bash
+echo "$${provider === "hubspot" ? "HUBSPOT_TOKEN" : "SALESFORCE_ACCESS_TOKEN"}" | fullstackgtm login ${provider}${p}
+echo "$${loginSource.toUpperCase()}_API_KEY" | fullstackgtm login ${loginSource}${p}
+\`\`\`
+
+## 1. Edit your targeting + assignment
+
+- \`icp.json\` — the starter ICP. Edit it, or rebuild: \`fullstackgtm icp interview\`
+  (an agent drives the questions) → \`fullstackgtm icp set answers.json\`.
+- \`${ENRICH_CONFIG_FILE_NAME}\` — set \`acquire.assign.ownerId\` (currently
+  \`${PLACEHOLDER_OWNER}\`) so acquired leads are never ownerless, or pass
+  \`--assign-owner <id>\` per run. Tune \`acquire.budget\` (records + spend caps).
+
+## 2. Cold start — fill the CRM with targeted, owned, emailed leads
+
+\`\`\`bash
+fullstackgtm enrich acquire --source ${source} --provider ${provider}${p} --json   # dry-run plan, writes NOTHING
+fullstackgtm enrich acquire --source ${source} --provider ${provider}${p} --save    # persist as needs_approval
+fullstackgtm plans approve <plan-id>${p} --operations all
+fullstackgtm apply --plan-id <plan-id> --provider ${provider}${p}
+\`\`\`
+
+Each lead lands owner-stamped and linked to a domain-stamped **account**, so the
+signals/judge layer can watch it.
+
+## 3. Outbound loop — reach an account the week something changes
+
+\`\`\`bash
+fullstackgtm signals fetch --bucket job,funding --watchlist crm:<segment>${p} --save
+fullstackgtm icp judge --signals-from latest --provider ${provider}${p} --save --json   # pass the snapshot → resolves accountId + contact
+fullstackgtm draft --from-judge latest --channel email${p} --save --json                # one grounded opener per hot account, as a create_task
+fullstackgtm plans approve <plan-id>${p} --operations all
+fullstackgtm apply --plan-id <plan-id> --provider ${provider}${p}
+# → the agent sends the approved opener via the operator's channel tool, then:
+fullstackgtm signals outcome --account <domain> --contact <contactId> --result replied${p}
+\`\`\`
+
+A domain-only judge decision (account not yet in the CRM) is rejected by \`draft\`
+with "acquire it first" — run step 2 for that account, then re-judge.
+
+## The boundary
+
+- **Read freely. Write only through \`plans approve → apply\`.**
+- **The package never sends.** \`draft\` is the last governed step.
+- **You are the orchestrator.** These are starting points — compose them.
+`;
+}
+/**
+ * Build the set of files `init` would write (pure — no IO). The caller decides
+ * which to actually write (skipping existing files unless --force).
+ */
+export function scaffoldWorkspace(opts = {}) {
+    const source = opts.source ?? "pipe0";
+    const provider = opts.provider ?? "hubspot";
+    return [
+        { path: "icp.json", content: `${JSON.stringify(starterIcp(), null, 2)}\n` },
+        {
+            path: ENRICH_CONFIG_FILE_NAME,
+            content: `${JSON.stringify(starterEnrichConfig(source), null, 2)}\n`,
+        },
+        { path: "PLAYBOOK.md", content: starterPlaybook({ source, provider, profile: opts.profile }) },
+    ];
+}

package/dist/judge.d.ts

@@ -26,6 +26,23 @@ import type { CanonicalGtmSnapshot } from "./types.ts";
 export type JudgeDecisionKind = "send" | "nurture" | "skip";
 export type JudgeDecision = {
     accountDomain: string;
+    /**
+     * The CRM account this domain resolves to, when a snapshot was provided.
+     * Absent = the account is not in the CRM (a net-new domain) — downstream
+     * verbs must acquire it before they can write against it.
+     */
+    accountId?: string;
+    /**
+     * The contact at the account to reach, when resolvable from the snapshot —
+     * the answer to "who do I message at this hot account". `draft` targets this
+     * contact's id; absent contact + present accountId targets the account.
+     */
+    contact?: ContactRef;
+    /**
+     * All in-CRM contacts at the account (primary first), capped — so an agent can
+     * multi-thread beyond the single primary. `contact` is `contacts[0]`.
+     */
+    contacts?: ContactRef[];
     /** 0-100. */
     score: number;
     decision: JudgeDecisionKind;
@@ -125,9 +142,9 @@ export declare function scoreAccount(opts: {
  */
 export declare function accountRecentlyTouched(accountDomain: string, snapshot: CanonicalGtmSnapshot, now?: Date, windowDays?: number): boolean;
 /**
- * Find the best-matching contact for an account from the snapshot, for fit
- * scoring: the account's contacts, preferring one with a title (a title is what
- * fit scores on). Returns undefined when the account/contact isn't in snapshot.
+ * Best-matching contact for an account, shaped for fit scoring (the title is
+ * what `scoreProspectAgainstIcp` reads). Returns undefined when the
+ * account/contact isn't in the snapshot.
  */
 export declare function bestContactForAccount(accountDomain: string, snapshot: CanonicalGtmSnapshot): {
     jobTitle?: string;
@@ -135,6 +152,22 @@ export declare function bestContactForAccount(accountDomain: string, snapshot: C
     jobDepartment?: string;
     headline?: string;
 } | undefined;
+/**
+ * Resolve the CRM target for an account domain: its `accountId` (when the
+ * account exists in the snapshot) and the best `contact` to reach (id + email +
+ * title). This is what `draft` writes against — a real record id, never the
+ * domain. `{}` when the account is not in the CRM (a net-new domain).
+ */
+export type ContactRef = {
+    id: string;
+    email?: string;
+    title?: string;
+};
+export declare function resolveAccountTarget(accountDomain: string, snapshot: CanonicalGtmSnapshot): {
+    accountId?: string;
+    contact?: ContactRef;
+    contacts?: ContactRef[];
+};
 /**
  * Build a `JudgeDecision` from an `AccountScore` with the deterministic baseline:
  * whyNow taken VERBATIM from the top credited signal's quote (grounded by