fullstackgtm 0.22.0 → 0.23.2

package/dist/enrichApollo.d.ts

@@ -0,0 +1,59 @@
+import type { CanonicalGtmSnapshot } from "./types.ts";
+import type { EnrichObjectType, EnrichSourceRecord, EnrichWorkItem } from "./enrich.ts";
+export type ApolloClientOptions = {
+    getApiKey: () => string | Promise<string>;
+    apiBaseUrl?: string;
+    /** Injectable fetch for testing — tests must never hit the real Apollo API. */
+    fetchImpl?: typeof fetch;
+    /** Max retries after a 429 (default 3). */
+    maxRetries?: number;
+    /** Injectable sleep for testing backoff without waiting. */
+    sleep?: (ms: number) => Promise<void>;
+};
+export type ApolloClient = {
+    /** GET /api/v1/organizations/enrich?domain=… → response body, or null on no data. */
+    enrichOrganization(domain: string): Promise<Record<string, unknown> | null>;
+    /** POST /api/v1/people/match { email } → response body, or null on no data. */
+    matchPerson(email: string): Promise<Record<string, unknown> | null>;
+};
+export declare function createApolloClient(options: ApolloClientOptions): ApolloClient;
+export type ApolloPullKey = {
+    objectType: EnrichObjectType;
+    /** "domain" for companies, "email" for contacts. */
+    key: "domain" | "email";
+    value: string;
+};
+export type ApolloPullResult = {
+    records: EnrichSourceRecord[];
+    /** Pull keys Apollo returned no data for. */
+    misses: ApolloPullKey[];
+};
+export type ApolloPullProgress = {
+    /** The pull key just processed — the run-store cursor value. */
+    lastKeyValue: string;
+    record?: EnrichSourceRecord;
+    miss?: ApolloPullKey;
+};
+export type ApolloPullOptions = {
+    /** Resume checkpoint: pull keys at or before this value are skipped. */
+    resumeAfter?: string | null;
+    /** Checkpoint callback after each pull key is processed. */
+    onProgress?: (progress: ApolloPullProgress) => void | Promise<void>;
+};
+/**
+ * Pull keys for an append run: records of the requested types where at least
+ * one configured field is blank and the pull key (companies: domain,
+ * contacts: email) is present. Deduplicated — two CRM companies sharing a
+ * domain produce ONE Apollo call, and the matcher then reports the collision.
+ */
+export declare function apolloPullKeysForAppend(snapshot: CanonicalGtmSnapshot, objectTypes: EnrichObjectType[], needsEnrichment: (objectType: EnrichObjectType, record: Record<string, unknown>) => boolean): ApolloPullKey[];
+/** Pull keys for a refresh run: the stale work set mapped back to pull keys. */
+export declare function apolloPullKeysForRefresh(snapshot: CanonicalGtmSnapshot, workSet: EnrichWorkItem[]): ApolloPullKey[];
+/**
+ * Execute the pull: one Apollo call per key, normalized into source records.
+ * Sequential on purpose (enrichment endpoints rate-limit aggressively); the
+ * 429 backoff lives in the client. `onProgress` checkpoints the run-store
+ * cursor after every key so an interrupted pull resumes instead of re-paying
+ * for completed lookups.
+ */
+export declare function pullApolloRecords(client: ApolloClient, keys: ApolloPullKey[], options?: ApolloPullOptions): Promise<ApolloPullResult>;

package/dist/enrichApollo.js

@@ -0,0 +1,192 @@
+/**
+ * Apollo source client for the enrich layer: raw fetch against Apollo's REST
+ * enrichment endpoints (people match, organization enrich), bring-your-own
+ * key (`login apollo`), no SDK.
+ *
+ * The one genuinely new HTTP behavior lives here and ONLY here: enrichment
+ * APIs rate-limit aggressively, so requests retry on 429 with capped
+ * exponential backoff (honoring Retry-After when present). The shared
+ * connector contract is deliberately untouched.
+ */
+const DEFAULT_API_BASE_URL = "https://api.apollo.io";
+const DEFAULT_MAX_RETRIES = 3;
+const BASE_BACKOFF_MS = 500;
+const MAX_BACKOFF_MS = 8_000;
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function retryDelayMs(response, attempt) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (Number.isFinite(seconds) && seconds >= 0)
+            return Math.min(seconds * 1000, MAX_BACKOFF_MS);
+        const at = Date.parse(retryAfter);
+        if (Number.isFinite(at))
+            return Math.min(Math.max(at - Date.now(), 0), MAX_BACKOFF_MS);
+    }
+    return Math.min(BASE_BACKOFF_MS * 2 ** attempt, MAX_BACKOFF_MS);
+}
+export function createApolloClient(options) {
+    const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const sleep = options.sleep ?? defaultSleep;
+    async function request(path, init = {}) {
+        const apiKey = await options.getApiKey();
+        for (let attempt = 0;; attempt += 1) {
+            let response;
+            try {
+                response = await fetchImpl(`${baseUrl}${path}`, {
+                    ...init,
+                    headers: {
+                        "X-Api-Key": apiKey,
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                        ...(init.headers ?? {}),
+                    },
+                });
+            }
+            catch (error) {
+                const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
+                throw new Error(`Cannot reach Apollo at ${baseUrl}${cause}. Check network access.`);
+            }
+            if (response.status === 429 && attempt < maxRetries) {
+                await sleep(retryDelayMs(response, attempt));
+                continue;
+            }
+            if (response.status === 404)
+                return null;
+            if (!response.ok) {
+                const body = await response.text();
+                const exhausted = response.status === 429 ? ` (rate limited; ${maxRetries} retries exhausted)` : "";
+                throw new Error(`Apollo API error ${response.status}${exhausted}: ${body}`);
+            }
+            const text = await response.text();
+            return text ? JSON.parse(text) : null;
+        }
+    }
+    return {
+        async enrichOrganization(domain) {
+            return request(`/api/v1/organizations/enrich?domain=${encodeURIComponent(domain)}`, {
+                method: "GET",
+            });
+        },
+        async matchPerson(email) {
+            return request("/api/v1/people/match", {
+                method: "POST",
+                body: JSON.stringify({ email }),
+            });
+        },
+    };
+}
+function stringAt(payload, path) {
+    let current = payload;
+    for (const segment of path) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[segment];
+    }
+    return typeof current === "string" && current ? current : undefined;
+}
+/**
+ * Pull keys for an append run: records of the requested types where at least
+ * one configured field is blank and the pull key (companies: domain,
+ * contacts: email) is present. Deduplicated — two CRM companies sharing a
+ * domain produce ONE Apollo call, and the matcher then reports the collision.
+ */
+export function apolloPullKeysForAppend(snapshot, objectTypes, needsEnrichment) {
+    const keys = [];
+    const seen = new Set();
+    for (const objectType of objectTypes) {
+        const records = objectType === "company" ? snapshot.accounts : snapshot.contacts;
+        const keyName = objectType === "company" ? "domain" : "email";
+        for (const record of records) {
+            const value = record[keyName]?.trim();
+            if (!value)
+                continue;
+            if (!needsEnrichment(objectType, record))
+                continue;
+            const dedupe = `${objectType}|${value.toLowerCase()}`;
+            if (seen.has(dedupe))
+                continue;
+            seen.add(dedupe);
+            keys.push({ objectType, key: keyName, value });
+        }
+    }
+    return keys;
+}
+/** Pull keys for a refresh run: the stale work set mapped back to pull keys. */
+export function apolloPullKeysForRefresh(snapshot, workSet) {
+    const keys = [];
+    const seen = new Set();
+    for (const item of workSet) {
+        const records = item.objectType === "company" ? snapshot.accounts : snapshot.contacts;
+        const record = records.find((entry) => entry.id === item.objectId);
+        if (!record)
+            continue;
+        const keyName = item.objectType === "company" ? "domain" : "email";
+        const value = record[keyName]?.trim();
+        if (!value)
+            continue;
+        const dedupe = `${item.objectType}|${value.toLowerCase()}`;
+        if (seen.has(dedupe))
+            continue;
+        seen.add(dedupe);
+        keys.push({ objectType: item.objectType, key: keyName, value });
+    }
+    return keys;
+}
+/**
+ * Execute the pull: one Apollo call per key, normalized into source records.
+ * Sequential on purpose (enrichment endpoints rate-limit aggressively); the
+ * 429 backoff lives in the client. `onProgress` checkpoints the run-store
+ * cursor after every key so an interrupted pull resumes instead of re-paying
+ * for completed lookups.
+ */
+export async function pullApolloRecords(client, keys, options = {}) {
+    const records = [];
+    const misses = [];
+    // Resume: skip keys up to and including the checkpoint. An unknown
+    // checkpoint (snapshot changed since the interrupted run) restarts cleanly.
+    const resumeIndex = options.resumeAfter
+        ? keys.findIndex((key) => key.value === options.resumeAfter)
+        : -1;
+    for (const key of keys.slice(resumeIndex + 1)) {
+        let record;
+        if (key.objectType === "company") {
+            const payload = await client.enrichOrganization(key.value);
+            const organization = payload?.organization;
+            if (organization) {
+                record = {
+                    id: `apollo:org_${stringAt(payload, ["organization", "id"]) ?? key.value}`,
+                    objectType: "company",
+                    keys: {
+                        domain: stringAt(payload, ["organization", "primary_domain"]) ?? key.value,
+                        name: stringAt(payload, ["organization", "name"]),
+                    },
+                    payload: payload,
+                };
+            }
+        }
+        else {
+            const payload = await client.matchPerson(key.value);
+            const person = payload?.person;
+            if (person) {
+                record = {
+                    id: `apollo:person_${stringAt(payload, ["person", "id"]) ?? key.value}`,
+                    objectType: "contact",
+                    keys: {
+                        email: stringAt(payload, ["person", "email"]) ?? key.value,
+                        name: stringAt(payload, ["person", "name"]),
+                    },
+                    payload: payload,
+                };
+            }
+        }
+        if (record)
+            records.push(record);
+        else
+            misses.push(key);
+        await options.onProgress?.({ lastKeyValue: key.value, record, miss: record ? undefined : key });
+    }
+    return { records, misses };
+}

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDevic
 export { createStripeConnector, type StripeConnectorOptions } from "./connectors/stripe.ts";
 export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, deleteCredential, getCredential, listProfiles, resolveHubspotAccessToken, resolveHubspotConnection, setActiveProfile, storeCredential, type HubspotConnection, type StoredCredential, } from "./credentials.ts";
 export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
+export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, type BuildEnrichPlanOptions, type EnrichAmbiguity, type EnrichConfig, type EnrichCounts, type EnrichFieldConfig, type EnrichMatchConfig, type EnrichMode, type EnrichObjectType, type EnrichPlanResult, type EnrichRun, type EnrichRunStore, type EnrichSourceConfig, type EnrichSourceRecord, type EnrichStamp, type EnrichWorkItem, type MatchOutcome, } from "./enrich.ts";
+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";
 export { createFilePlanStore, type PlanStore, type StoredPlan } from "./planStore.ts";

package/dist/index.js

@@ -11,6 +11,8 @@ export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDevic
 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 { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, } from "./enrichApollo.js";
 export { diffFindings, diffSnapshots, diffToMarkdown, } from "./diff.js";
 export { mergeSnapshots, } from "./merge.js";
 export { createFilePlanStore } from "./planStore.js";

package/dist/marketReport.js

@@ -400,6 +400,9 @@ export function marketMapToHtml(config, set) {
             `<span class="claim-meta">${e(claim.icp)} · ${e(claim.pricingStructure)}</span></th>${cells}` +
             `<td class="front"><span class="chip chip-${state}">${state.toUpperCase()}</span></td></tr>`);
     };
+    const vendorHeads = config.vendors
+        .map((vendor) => `<th class="vh${vendor.id === anchor ? " anchor-col" : ""}"><span>${e(vendor.name)}</span></th>`)
+        .join("");
     // Claims grouped by front state, each group a collapsed <details> whose
     // summary carries the stats a skimmer needs; the full matrix is one click
     // away, not a wall the reader must climb to reach the takeaway.
@@ -418,7 +421,7 @@ export function marketMapToHtml(config, set) {
             : 0;
         const anchorNote = anchor ? ` · ${vendorNamesById.get(anchor) ?? anchor} loud on ${anchorLoud}` : "";
         return `<details class="claim-group"><summary><b>${e(group.title)}</b> — ${claimIds.length} claim${claimIds.length === 1 ? "" : "s"} <span class="sum-soft">(${e(group.blurb)}${anchorNote})</span></summary>
-      <table><thead><tr><th></th>${"${vendorHeads}"}<th></th></tr></thead><tbody>${claimIds.map(matrixRow).join("")}</tbody></table>
+      <table><thead><tr><th></th>${vendorHeads}<th></th></tr></thead><tbody>${claimIds.map(matrixRow).join("")}</tbody></table>
     </details>`;
     }).join("");
     // The closing argument: walk from open ground to a reasoned target list.
@@ -481,9 +484,6 @@ export function marketMapToHtml(config, set) {
         return `<details class="ev-group"><summary><b>${e(vendor.name)}</b> <span class="sum-soft">— ${items.length} quoted span${items.length === 1 ? "" : "s"}</span></summary>${items.join("")}</details>`;
     })
         .join("");
-    const vendorHeads = config.vendors
-        .map((vendor) => `<th class="vh${vendor.id === anchor ? " anchor-col" : ""}"><span>${e(vendor.name)}</span></th>`)
-        .join("");
     return `<!doctype html>
 <html lang="en"><head><meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -571,7 +571,7 @@ footer { margin-top:60px; border-top:1px solid var(--ink); padding-top:12px; fon
 </header>
 ${axisHtml.strategicMap}
 <section>
-  <h2>Claims, front by front</h2>
+  <h2>Market Claims</h2>
   <div class="key">
     <span class="lg"><i class="g g-loud"></i>LOUD — hero-level claim</span>
     <span class="lg"><i class="g g-quiet"></i>QUIET — shipped, buried</span>

package/docs/api.md

@@ -59,8 +59,10 @@ release.
 
 Commands: `login` / `logout`, `snapshot`, `audit`, `report`, `diff`, `merge`, `plans`,
 `apply`, `suggest`, `call` (`parse` / `score` / `link` / `plan`), `resolve`,
+`bulk-update`, `dedupe`, `reassign`, `fix`,
 `market` (`init` / `capture` / `classify` / `worksheet` / `observe` / `fronts` /
-`axes` / `report` / `refresh`), `rules`, `profiles`, `doctor`.
+`axes` / `overlay` / `scale` / `report` / `refresh`),
+`enrich` (`append` / `refresh` / `ingest` / `status`), `rules`, `profiles`, `doctor`.
 Exit codes: `0` success · `1` error · `2` findings/regressions at the requested gate
 (`--fail-on`, `--fail-on-new-findings`). `--json` everywhere; JSON output shapes are stable.
 
@@ -80,19 +82,59 @@ deliverable in markdown or self-contained HTML: severity counts, prose summary,
 per-rule detail with capped examples, and next steps. `auditReportToMarkdown` /
 `auditReportToHtml` expose the same rendering programmatically.
 
+## Governed write verbs
+
+Plan builders behind `bulk-update`, `dedupe`, and `reassign` — every one
+emits a standard dry-run `PatchPlan` for the normal approve → apply chain:
+
+- `buildBulkUpdatePlan(snapshot, options: BulkUpdateOptions)` with
+  `parseWhere` (filter expressions: `=`, `!=`, `~`, `!~`, `:empty`,
+  `:notempty`, `|` any-of, relational pseudo-fields) and
+  `isFilterableField`. Filters are re-verified per record at apply time;
+  `from:<sourceField>` values derive per record from the snapshot.
+- `buildDedupePlan(snapshot, options: DedupeOptions)` with `dedupeKey` —
+  duplicate groups by normalized identity key, one `merge_records` per group,
+  deterministic survivor selection (`richest` / `oldest`).
+- `buildReassignPlans(snapshot, options: ReassignOptions)` — one plan per
+  `ReassignObjectType`, account-lifted scoping, stage exclusions.
+
+`fix` is CLI-only composition of existing surfaces (audit → suggest →
+approve → apply for one rule).
+
+## Enrich
+
+Governed third-party enrichment (spec-first; `enrich.config.json` validated
+by `parseEnrichConfig` / `loadEnrichConfig`, types `EnrichConfig`,
+`EnrichFieldConfig`, `EnrichSourceConfig`): `buildEnrichPlan` matches staged
+or pulled source records to CRM records (`matchSourceRecord` — ordered keys,
+`MatchOutcome` of matched / unmatched / ambiguous) and emits fill-blanks-only
+operations. `createFileEnrichRunStore` / `EnrichRunStore` is the profile-scoped
+append-only run store (resume cursor, per-record/per-field `enrichedAt`
+stamps read by `latestStamps` / `selectStaleWork`). `parseCsv` is the
+dependency-free CSV intake; the Apollo client (`createApolloClient`,
+`pullApolloRecords`, 429-aware with `Retry-After`) is the first `api`-kind
+source.
+
 ## Market map
 
-Newer surface (0.16–0.18); shapes are settling toward the 1.0 contract. A live
+Newer surface (0.16–0.23); shapes are settling toward the 1.0 contract. A live
 model of the competitive category: claim taxonomy + vendor registry as a
 reviewable `market.config.json` (`MarketConfig`, `MarketClaim`, `MarketVendor`,
-`MarketAxis`), content-addressed page captures (`captureMarket`,
-`loadCaptureTexts`), append-only observations (`ObservationSet`,
-`MarketObservation`, `ObservationStore` / `createFileObservationStore` —
-profile-scoped under `<home>/market/<category>`), and deterministic
-derivations: `computeFrontStates` / `diffFrontStates` (front rule v1),
-`assessAxes` / `pcaTop2` / `axisPosition` (axis discovery), and
+`MarketAxis` — axes require `negativePole`/`positivePole` labels), content-addressed
+page captures (`captureMarket`, `loadCaptureTexts`), append-only observations
+(`ObservationSet`, `MarketObservation`, `ObservationStore` /
+`createFileObservationStore` — profile-scoped under `<home>/market/<category>`),
+and deterministic derivations: `computeFrontStates` / `diffFrontStates`
+(front rule v1), `assessAxes` / `pcaTop2` / `axisPosition` (axis discovery),
+`computeDirectives` / `computeOverlayStats` / `directivesToPlan`
+(`market overlay` — observations × CRM snapshot × call corpus →
+OCCUPY/PROMOTE/URGENT/RETREAT `MarketDirective`s, convertible to an
+approval-gated plan of `create_task` operations), `computeScaleIndex` /
+`scaleReportToText` (`market scale` — citable `ScaleSignal`s → within-set,
+ACV-band-stratified revenue estimates with disclosed uncertainty), and
 `marketMapToMarkdown` / `marketMapToHtml` (the field report; renders the
-primary strategic 2×2 when `axes` / `primaryAxes` are configured).
+primary strategic 2×2 when `axes` / `primaryAxes` are configured, bubbles
+area-proportional to estimated revenue share when scale signals exist).
 
 Intensity readings are proposals: `classifyMarket` (LLM, bring-your-own-key,
 provenance-marked) or `buildWorksheet` + `market observe` (agent/human). Every

package/llms.txt

@@ -44,9 +44,49 @@ elsewhere). Failed captures read UNOBSERVABLE, never ABSENT. `fronts --diff`
 = deterministic front states + drift between runs; `axes` = PCA axis
 discovery + orthogonality screen; `report` = self-contained HTML field
 report; `refresh` = capture → classify → drift → report in one command.
+`overlay --snapshot <crm.json> [--calls <files>]` joins observations to YOUR
+CRM/calls (deterministic mention matching, no LLM) and emits OCCUPY/PROMOTE/
+URGENT/RETREAT directives — each needs ≥1 observation + ≥1 CRM stat with
+sample size; below thresholds = no directive; `--save` = approval-gated
+create_task ops. `scale` = citable scaleSignals (sourceUrl + verbatim quote
+each) → revenue-space estimates calibrated within-set by acvBand, disclosed
+uncertainty; report bubbles ∝ estimated share only when signals exist.
 Storage is profile-scoped under `<home>/market/<category>`. MCP:
 `fullstackgtm_market_worksheet`, `fullstackgtm_market_observe`.
 
+## Key invariants (governed write verbs)
+
+`bulk-update <object> --where … (--set|--archive|--create-task)` filters the
+snapshot into a dry-run plan; the FULL filter is re-verified per record at
+apply time (plus mid-apply rechecks); equality filters double as
+preconditions, `--require`/`--guard` add explicit ones, `--max-operations`
+caps blast radius. `--set f=from:<source>` derives per-record values (empty
+source = skip + count, never guess). `--archive` refuses records sharing an
+identity key — merge with `dedupe` instead. `dedupe <object> --key
+<domain|email|name>` = one merge_records op per duplicate group,
+deterministic survivor (`--keep richest|oldest`); merges are irreversible and
+stay low-confidence-capped at approval. `reassign --from <owner> --to
+<owner>` = ownership handoff plans per object type; `--except-deal-stage`
+also excludes records whose account has an open deal in that stage. `fix
+--rule <id>` = audit one rule → suggest → approve at the confidence bar →
+apply only with `--yes`. All four produce plans; none writes outside
+approve → apply.
+
+## Key invariants (enrich)
+
+`fullstackgtm enrich` is governed enrichment: `append` pulls (Apollo, BYO key
+via `login apollo`/APOLLO_API_KEY) or reads data staged by `ingest` (Clay CSV
+exports / webhook payload JSON), matches source records to CRM records via
+ordered keys in `enrich.config.json` (unique hit wins; ambiguity skips or
+becomes `requires_human_record_selection` placeholders — never a coin flip),
+and emits a fill-blanks-only patch plan through the normal dry-run → approve →
+apply gate. No `--save` = dry-run diff, nothing written. `refresh` re-checks
+stale fields the run-store ledger proves enrich stamped, proposing ops only
+where the source value changed (beforeValue = current CRM value → apply-time
+CAS). Conflict policy MVP is `never`; `system-only`/`always` are phase 2 and
+refused explicitly. Run store (checkpoint + staleness ledger + `status`) is
+profile-scoped under `<home>/enrich/runs`. No cron — scheduling is horizontal.
+
 ## Key invariants
 
 - Reads are safe by default; nothing is written without explicit `--approve`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.22.0",
+  "version": "0.23.2",
   "description": "Open-source agentic GTM ops framework: canonical GTM data model, pluggable deterministic audits, reviewable dry-run patch plans, approval-gated write-back with conflict detection, and cross-system entity resolution. HubSpot, Salesforce, and Stripe connectors included.",
   "license": "Apache-2.0",
   "author": "Full Stack GTM",