fullstackgtm 0.14.1 → 0.16.0

package/CHANGELOG.md

@@ -5,6 +5,76 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 The path to 1.0 is planned in [docs/roadmap-to-1.0.md](./docs/roadmap-to-1.0.md).
 
+## [0.16.0] — 2026-06-11
+
+The market map: a live model of the competitive category a company sells
+into — claim taxonomy as reviewable config, append-only observations with
+verbatim-quote evidence, deterministic front states and drift.
+
+### Added
+
+- **`fullstackgtm market`** — `init` scaffolds a `market.config.json`
+  (vendor registry + claim taxonomy + the LOUD/QUIET/ABSENT surface rule);
+  `capture` fetches vendor pages into a content-addressed text cache (the
+  change detector, replay buffer, and evidence chain); `observe --from`
+  ingests intensity readings after validating full coverage and the
+  verbatim-evidence rule (a loud/quiet reading with no quote is rejected);
+  `fronts` computes deterministic front states (open / contested / owned /
+  saturated / vacant) and `--diff` reports drift between runs; `report`
+  renders the claim × vendor matrix as markdown or a self-contained
+  printable HTML field report with an evidence appendix.
+- **Division of labor matches call intelligence:** intensity readings are
+  proposals (provenance-marked extractor, always with quoted evidence);
+  everything downstream is deterministic over the stored observations —
+  same observations, same map. A failed capture reads as UNOBSERVABLE,
+  never as absence.
+- **Profile-scoped storage:** captures and observations live under
+  `~/.fullstackgtm/market/<category>` (or the active profile's home), so one
+  client org's category intel never bleeds into another's.
+- `ObservationStore` contract + file implementation (append-only, one JSON
+  document per run) — like the plan store, the file layout and the hosted
+  backend are two implementations of the same contract.
+- `"web"` joined `GtmEvidenceSourceSystem`: market observations carry
+  standard `GtmEvidence` with `metadata.url` + `metadata.captureHash`.
+
+## [0.15.1] — 2026-06-11
+
+Fixes from the 0.15.0 journey verification (4 agents, 26 checks).
+
+### Fixed
+
+- **Name-only deal resolution is gated**: `resolve deal --name X` without
+  `--account-id` returned safe_to_create even when open deals named X
+  existed — a gate that ignores name collisions protects nobody. It now
+  returns ambiguous with the colliding open deals and tells the caller to
+  supply `--account-id` for a definitive answer.
+- The closed-deals-share-name note is account-scoped (it previously counted
+  closed deals on *other* accounts).
+- The `hs_object_source_detail_2` stamp on CLI-created companies now
+  carries the operation id for precise attribution.
+
+## [0.15.0] — 2026-06-11
+
+The Prevent layer: stop creating duplicates, and name the writer that does.
+
+### Added
+
+- **`fullstackgtm resolve <account|contact|deal>`** — the create gate.
+  Deterministic verdicts (exists / ambiguous / safe_to_create) with matches
+  and reasons, using the same identity keys as the audit/merge engines:
+  normalized account domain, contact email, open-deal key. Names alone are
+  never identity (ambiguous, with candidates). Gate-shaped exit codes for
+  scripts: 0 = safe to create, 2 = match found, 1 = error. Exposed as
+  `resolveRecord()` and MCP `fullstackgtm_resolve`.
+- **Record provenance** (`RecordProvenance` on accounts/contacts/deals):
+  HubSpot snapshots capture the read-only `hs_object_source`,
+  `hs_object_source_label`, `hs_object_source_id` fields, and the three
+  duplicate rules append writer attribution to findings — "Created by:
+  Gojiberry (app-123) ×2, CRM_UI" — so recurring dupes are fixed at the
+  faucet. Provenance is exempt from merge conflicts and diff drift, and
+  records created by the CLI's own `create:` path stamp
+  `hs_object_source_detail_2` (best-effort).
+
 ## [0.14.1] — 2026-06-11
 
 Fixes from the 0.14.0 journey verification (4 agents, 21 checks).

package/README.md

@@ -74,6 +74,20 @@ for t in transcripts/*; do fullstackgtm call parse --transcript "$t" --ndjson --
 
 The boundary that remains: Slack/Notion/warehouse sinks are *your* pipeline, composed around the JSON — and your rubrics and keys stay yours.
 
+## The create gate: no new dupes
+
+Detection cleans up yesterday's duplicates; the **resolve gate** prevents tomorrow's. Before any writer — a sync job, a webhook handler, an agent, your own script — creates a record, ask the gate:
+
+```bash
+fullstackgtm resolve contact --email jane@acme.com --input snap.json   # exit 0 = safe to create
+fullstackgtm resolve account --domain acme.com --provider hubspot      # exit 2 = exists/ambiguous: do NOT create
+fullstackgtm resolve deal --name "Acme Expansion" --account-id 123 --input snap.json
+```
+
+Identity keys match the audit/merge engines exactly: account domain (normalized), contact email, and the open-deal key (account + normalized name). Names alone are never identity — they return `ambiguous` with the candidates, not a guess. Exit codes are gate-shaped for scripts: `0` safe to create, `2` match found, `1` error. For high-volume writers, pair it with a cron-refreshed snapshot file rather than a live `--provider` fetch per call. Also exposed as `resolveRecord()` and the MCP tool `fullstackgtm_resolve`.
+
+**Provenance attribution** closes the loop on recurring dupes: snapshots now capture each record's source (HubSpot's read-only `hs_object_source*` fields), and duplicate findings name the writer — `"3 accounts share acme.com … Created by: Gojiberry (app-123) ×2, CRM_UI"` — so you fix the integration, not just the records. Records created by this CLI stamp their own provenance (`hs_object_source_detail_2`, best-effort).
+
 ## From findings to fixes: the suggest chain
 
 Most placeholder answers are already derivable from your own CRM data. `suggest` computes them deterministically — account-name matching cross-checked against contact associations — with a confidence level and a written reason per operation, so you (or an agent) approve evidence, not guesses:

package/dist/cli.js

@@ -18,7 +18,10 @@ import { auditReportToHtml, auditReportToMarkdown } from "./report.js";
 import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall, suggestCallDeal } from "./calls.js";
+import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadMarketConfig, starterMarketConfig, validateObservationSet, } from "./market.js";
+import { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 import { DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
+import { resolveRecord } from "./resolve.js";
 import { suggestValues } from "./suggest.js";
 function usage() {
     return `FullStackGTM — audit GTM data across providers, propose reviewable patch plans,
@@ -51,6 +54,18 @@ Usage:
                                                ANTHROPIC_API_KEY/OPENAI_API_KEY, or \`login anthropic|openai\`);
                                                --deterministic uses the free keyword baseline. Then link the call
                                                to its deal and propose governed next-step writes.
+  fullstackgtm resolve <account|contact|deal> [--name N] [--domain D] [--email E] [--account-id A] [source options] [--json]
+                                               the create gate: exit 0 = safe to create, exit 2 = match
+                                               found (exists/ambiguous) — call before ANY record creation
+  fullstackgtm market init --category <name>   start a market map: vendors + claim taxonomy as reviewable config
+  fullstackgtm market capture [--config <path>] [--run <label>]
+  fullstackgtm market observe --from <observations.json>
+  fullstackgtm market fronts [--run <label>] [--diff <prior-run>] [--json]
+  fullstackgtm market report [--run <label>] [--format md|html] [--out <path>]
+                                               the live competitive map: capture vendor pages (content-addressed),
+                                               ingest intensity readings with verbatim-quote evidence, compute
+                                               deterministic front states (open/contested/owned/saturated) and
+                                               drift between runs, render the client-ready field report
   fullstackgtm suggest --plan-id <id> | --plan <path>  [source options] [--json] [--out <path>]
                                                derive values for requires_human_* placeholders
                                                from snapshot evidence, with confidence + reasons
@@ -711,6 +726,152 @@ function buildCallPlan(parsed, deal, proposed, current, extraNextSteps) {
         operations,
     };
 }
+/**
+ * The market map: claim taxonomy in a reviewable config file, page captures
+ * and append-only observations under the profile home, deterministic front
+ * states and reports computed from the store. Classification (LLM intensity
+ * readings) lands in a later change; until then `market observe --from`
+ * ingests proposal files produced by an agent or a human.
+ */
+async function marketCommand(args) {
+    const [subcommand, ...rest] = args;
+    const configPath = () => resolve(process.cwd(), option(rest, "--config") ?? "market.config.json");
+    if (!subcommand || subcommand === "--help") {
+        console.log(`Usage:
+market init --category <name> [--out <path>]   write a starter market.config.json
+market capture [--config <path>] [--run <label>]
+market observe --from <observations.json> [--config <path>]
+market fronts [--config <path>] [--run <label>] [--diff <prior-run>] [--json]
+market report [--config <path>] [--run <label>] [--format md|html] [--out <path>]
+
+The taxonomy (vendors + claims) is config you review and version; captures
+and observations live under ~/.fullstackgtm/market/<category> (profile-scoped,
+one client's category intel never bleeds into another's). Front states are
+recomputed deterministically on every invocation — never stored.`);
+        return;
+    }
+    if (subcommand === "init") {
+        const category = option(rest, "--category");
+        if (!category)
+            throw new Error("market init requires --category <name>");
+        const outPath = resolve(process.cwd(), option(rest, "--out") ?? "market.config.json");
+        if (existsSync(outPath))
+            throw new Error(`${outPath} already exists — refusing to overwrite`);
+        writeFileSync(outPath, `${JSON.stringify(starterMarketConfig(category), null, 2)}\n`);
+        console.log(`Wrote ${outPath}. Fill in vendors and claims, then: fullstackgtm market capture`);
+        return;
+    }
+    const config = loadMarketConfig(configPath());
+    const store = createFileObservationStore(config.category);
+    if (subcommand === "capture") {
+        const result = await captureMarket(config, { runLabel: option(rest, "--run") ?? "run-1" });
+        for (const entry of result.entries) {
+            const flag = entry.captureHash && entry.textChars > 500 ? "" : "  <-- thin/empty";
+            console.log(`${entry.vendorId.padEnd(16)} ${entry.kind.padEnd(8)} ${String(entry.httpStatus ?? "ERR").padEnd(4)} ${String(entry.textChars).padStart(7)} chars  ${entry.url}${flag}`);
+        }
+        console.log(`\nmanifest: ${result.manifestPath}`);
+        return;
+    }
+    if (subcommand === "observe") {
+        const fromPath = option(rest, "--from");
+        if (!fromPath)
+            throw new Error("market observe requires --from <observations.json>");
+        const set = JSON.parse(readFileSync(resolve(process.cwd(), fromPath), "utf8"));
+        const problems = validateObservationSet(config, set);
+        if (problems.length > 0) {
+            console.error(`Rejected: ${problems.length} problem(s)`);
+            for (const problem of problems.slice(0, 20))
+                console.error(`  - ${problem}`);
+            process.exitCode = 1;
+            return;
+        }
+        await store.append(set);
+        console.log(`Appended ${set.runLabel}: ${set.observations.length} observations (${set.extractor})`);
+        return;
+    }
+    const loadSet = async () => {
+        const runLabel = option(rest, "--run");
+        const set = runLabel ? await store.get(runLabel) : await store.latest();
+        if (!set) {
+            throw new Error(runLabel
+                ? `No observation run "${runLabel}" for ${config.category}`
+                : `No observations stored for ${config.category} — run market observe --from <file> first`);
+        }
+        return set;
+    };
+    if (subcommand === "fronts") {
+        const set = await loadSet();
+        const fronts = computeFrontStates(config, set);
+        const priorLabel = option(rest, "--diff");
+        const prior = priorLabel ? await store.get(priorLabel) : null;
+        if (priorLabel && !prior)
+            throw new Error(`No observation run "${priorLabel}" to diff against`);
+        const drift = prior ? diffFrontStates(computeFrontStates(config, prior), fronts) : null;
+        if (rest.includes("--json")) {
+            console.log(JSON.stringify({ runLabel: set.runLabel, fronts, drift }, null, 2));
+            return;
+        }
+        for (const front of fronts) {
+            const owner = front.state === "owned" ? ` → ${front.loudVendorIds[0]}` : "";
+            console.log(`${front.state.toUpperCase().padEnd(10)} ${front.claimId}${owner}`);
+        }
+        if (drift) {
+            console.log("");
+            if (drift.length === 0)
+                console.log(`No front changes since ${priorLabel}.`);
+            for (const change of drift)
+                console.log(`CHANGED   ${change.claimId}: ${change.before} → ${change.after}`);
+        }
+        return;
+    }
+    if (subcommand === "report") {
+        const set = await loadSet();
+        const format = option(rest, "--format") ?? "md";
+        const output = format === "html" ? marketMapToHtml(config, set) : marketMapToMarkdown(config, set);
+        const outPath = option(rest, "--out");
+        if (outPath) {
+            writeFileSync(resolve(process.cwd(), outPath), output);
+            console.log(`Wrote ${outPath}`);
+        }
+        else {
+            console.log(output);
+        }
+        return;
+    }
+    throw new Error(`Unknown market subcommand: ${subcommand} (try: init, capture, observe, fronts, report)`);
+}
+/**
+ * The resolve gate: exit 0 = safe to create, exit 2 = match found (exists or
+ * ambiguous — do NOT blind-create), exit 1 = error. Built for sync jobs and
+ * webhook handlers to call before any record creation.
+ */
+async function resolveCommand(args) {
+    const [objectType, ...rest] = args;
+    if (!objectType || !["account", "contact", "deal"].includes(objectType)) {
+        throw new Error("Usage: fullstackgtm resolve <account|contact|deal> [--name N] [--domain D] [--email E] [--account-id A] [source options] [--json]");
+    }
+    const candidate = {
+        objectType: objectType,
+        name: option(rest, "--name") ?? undefined,
+        domain: option(rest, "--domain") ?? undefined,
+        email: option(rest, "--email") ?? undefined,
+        accountId: option(rest, "--account-id") ?? undefined,
+    };
+    const snapshot = await readSnapshot(rest);
+    const result = resolveRecord(snapshot, candidate);
+    if (rest.includes("--json")) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        const marker = result.verdict === "safe_to_create" ? "✓" : result.verdict === "exists" ? "=" : "?";
+        console.log(`${marker} [${result.verdict}] ${result.reason}`);
+        for (const m of result.matches) {
+            console.log(`    ${m.id} "${m.name}" — matched by ${m.matchedBy}: ${m.detail}`);
+        }
+    }
+    if (result.verdict !== "safe_to_create")
+        process.exitCode = 2;
+}
 async function suggest(args) {
     const planId = option(args, "--plan-id");
     const planPath = option(args, "--plan");
@@ -1456,6 +1617,14 @@ export async function runCli(argv) {
         await callCommand(args);
         return;
     }
+    if (command === "resolve") {
+        await resolveCommand(args);
+        return;
+    }
+    if (command === "market") {
+        await marketCommand(args);
+        return;
+    }
     if (command === "profiles") {
         profilesCommand(args);
         return;

package/dist/connectors/hubspot.js

@@ -84,7 +84,10 @@ export function createHubspotConnector(options) {
             email: stringOrUndefined(owner.email),
             active: owner.archived !== true,
         }));
-        const companyProperties = mappedFields(mappings, "accounts", HUBSPOT_DEFAULT_FIELD_MAPPINGS.accounts).join(",");
+        // Read-only record-source fields power duplicate-finding attribution
+        // ("all five created by integration X") — see RecordProvenance.
+        const PROVENANCE_PROPERTIES = "hs_object_source,hs_object_source_label,hs_object_source_id";
+        const companyProperties = `${mappedFields(mappings, "accounts", HUBSPOT_DEFAULT_FIELD_MAPPINGS.accounts).join(",")},${PROVENANCE_PROPERTIES}`;
         const companies = await fetchObjects("companies", companyProperties, false);
         const accounts = companies
             .filter((company) => company.id)
@@ -101,11 +104,12 @@ export function createHubspotConnector(options) {
                 employeeCount: numberOrUndefined(readMapped(props, "accounts", "employeeCount", "numberofemployees")),
                 annualRevenue: numberOrUndefined(readMapped(props, "accounts", "annualRevenue", "annualrevenue")),
                 ownerId: stringOrUndefined(readMapped(props, "accounts", "ownerId", "hubspot_owner_id")),
+                provenance: provenanceFrom(props),
                 lastSyncAt: stringOrUndefined(company.updatedAt),
                 raw: company,
             };
         });
-        const contactProperties = mappedFields(mappings, "contacts", HUBSPOT_DEFAULT_FIELD_MAPPINGS.contacts).join(",");
+        const contactProperties = `${mappedFields(mappings, "contacts", HUBSPOT_DEFAULT_FIELD_MAPPINGS.contacts).join(",")},${PROVENANCE_PROPERTIES}`;
         const hubspotContacts = await fetchObjects("contacts", contactProperties, true);
         const contacts = hubspotContacts
             .filter((contact) => contact.id)
@@ -124,11 +128,12 @@ export function createHubspotConnector(options) {
                 phone: stringOrUndefined(readMapped(props, "contacts", "phone", "phone")),
                 title: stringOrUndefined(readMapped(props, "contacts", "title", "jobtitle")),
                 ownerId: stringOrUndefined(readMapped(props, "contacts", "ownerId", "hubspot_owner_id")),
+                provenance: provenanceFrom(props),
                 lastSyncAt: stringOrUndefined(contact.updatedAt),
                 raw: contact,
             };
         });
-        const dealProperties = mappedFields(mappings, "deals", HUBSPOT_DEFAULT_FIELD_MAPPINGS.deals).join(",");
+        const dealProperties = `${mappedFields(mappings, "deals", HUBSPOT_DEFAULT_FIELD_MAPPINGS.deals).join(",")},${PROVENANCE_PROPERTIES}`;
         const hubspotDeals = await fetchObjects("deals", dealProperties, true);
         const deals = hubspotDeals
             .filter((deal) => deal.id)
@@ -152,6 +157,7 @@ export function createHubspotConnector(options) {
                 identities: [{ provider: "hubspot", externalId: String(deal.id) }],
                 accountId: companyId ? String(companyId) : undefined,
                 ownerId: stringOrUndefined(readMapped(props, "deals", "ownerId", "hubspot_owner_id")),
+                provenance: provenanceFrom(props),
                 name: stringOrFallback(readMapped(props, "deals", "name", "dealname"), "Untitled Deal"),
                 amount: numberOrUndefined(readMapped(props, "deals", "amount", "amount")),
                 stage,
@@ -323,10 +329,23 @@ export function createHubspotConnector(options) {
                     createdCompaniesByName.set(nameKey, companyId);
                 }
                 else {
-                    const created = await request(`/crm/v3/objects/companies`, {
-                        method: "POST",
-                        body: JSON.stringify({ properties: { name } }),
-                    });
+                    let created;
+                    try {
+                        created = await request(`/crm/v3/objects/companies`, {
+                            method: "POST",
+                            body: JSON.stringify({
+                                properties: { name, hs_object_source_detail_2: `fullstackgtm create: (${operation.id})` },
+                            }),
+                        });
+                    }
+                    catch {
+                        // Some portals reject writes to source-detail properties — the
+                        // provenance stamp is best-effort, the create is not.
+                        created = await request(`/crm/v3/objects/companies`, {
+                            method: "POST",
+                            body: JSON.stringify({ properties: { name } }),
+                        });
+                    }
                     companyId = String(created.id);
                     createdCompanyName = name;
                     createdCompaniesByName.set(nameKey, companyId);
@@ -394,6 +413,34 @@ export function createHubspotConnector(options) {
         catch {
             // fall through to create
         }
+        // A live CRM often already carries a human-created follow-up for the same
+        // record (a previous partial run, or a rep's own task). Creating another
+        // on top is duplicate noise — skip when the object already has an open
+        // task, regardless of who created it. Fail-open: a lookup hiccup must
+        // not block the apply.
+        try {
+            const objectPath = OBJECT_PATHS[operation.objectType];
+            const assoc = await request(`/crm/v4/objects/${objectPath}/${encodeURIComponent(operation.objectId)}/associations/tasks?limit=20`);
+            const taskIds = (assoc?.results ?? [])
+                .map((row) => String(row.toObjectId ?? ""))
+                .filter(Boolean)
+                .slice(0, 10);
+            for (const taskId of taskIds) {
+                const existingTask = await request(`/crm/v3/objects/tasks/${encodeURIComponent(taskId)}?properties=hs_task_status`);
+                const status = String(existingTask?.properties?.hs_task_status ?? "");
+                if (status !== "COMPLETED" && status !== "DELETED") {
+                    return {
+                        operationId: operation.id,
+                        status: "skipped",
+                        detail: `An open task (task ${taskId}) already exists on ${operation.objectType}/${operation.objectId}; not creating a duplicate follow-up.`,
+                        providerData: { id: taskId, existing: true },
+                    };
+                }
+            }
+        }
+        catch {
+            // fall through to create
+        }
         const body = `${String(operation.afterValue ?? operation.reason ?? "")}\n\n[${token}]`;
         const response = await request(`/crm/v3/objects/tasks`, {
             method: "POST",
@@ -567,6 +614,14 @@ export function createHubspotConnector(options) {
         readField,
     };
 }
+function provenanceFrom(props) {
+    const source = stringOrUndefined(props.hs_object_source);
+    const sourceLabel = stringOrUndefined(props.hs_object_source_label);
+    const sourceId = stringOrUndefined(props.hs_object_source_id);
+    if (!source && !sourceLabel && !sourceId)
+        return undefined;
+    return { source, sourceLabel, sourceId };
+}
 function stringOrUndefined(value) {
     if (value === undefined || value === null || value === "")
         return undefined;

package/dist/diff.js

@@ -4,7 +4,7 @@
  * appeared, what disappeared, what changed — and whether hygiene regressed.
  */
 // Fields that change on every sync without semantic meaning.
-const IGNORED_FIELDS = new Set(["raw", "lastSyncAt", "identities"]);
+const IGNORED_FIELDS = new Set(["raw", "lastSyncAt", "identities", "provenance"]);
 function labelOf(record) {
     return record.name ?? record.email ?? record.id;
 }

package/dist/index.d.ts

@@ -14,9 +14,12 @@ export { createFilePlanStore, type PlanStore, type StoredPlan } from "./planStor
 export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.ts";
 export { auditReportToHtml, auditReportToMarkdown, type ReportOptions } from "./report.ts";
 export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, type CrmObjectType, type FieldMappings, } from "./mappings.ts";
-export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, requiresHumanInput, staleDealRule, } from "./rules.ts";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.ts";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, type CallDealSuggestion, type CallInsightType, type ExtractedCallInsight, type ParsedCall, type ParsedTranscriptSegment, } from "./calls.ts";
 export { sampleSnapshot } from "./sampleData.ts";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, type CallScorecard, type LlmCredential, type LlmExtractedInsight, type LlmProvider, type Rubric, type ScoredDimension, } from "./llm.ts";
+export { resolveRecord, type ResolveCandidate, type ResolveMatch, type ResolveResult } from "./resolve.ts";
+export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadMarketConfig, marketHome, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, type CaptureEntry, type CaptureOptions, type ClaimFront, type ClaimIntensity, type FrontDrift, type FrontState, type MarketClaim, type MarketConfig, type MarketObservation, type MarketVendor, type ObservationConfidence, type ObservationSet, type ObservationStore, } from "./market.ts";
+export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.ts";
 export { suggestValues, type SuggestionConfidence, type ValueSuggestion } from "./suggest.ts";
 export type { ApprovalStatus, AuditFinding, AuditFindingSeverity, CanonicalAccount, CanonicalActivity, CanonicalContact, CanonicalDeal, CanonicalGtmSnapshot, CanonicalUser, CrmProvider, GtmAuditRule, GtmConnector, GtmEvidence, GtmEvidenceSourceSystem, GtmObjectType, GtmPolicy, GtmRuleContext, GtmRuleResult, GtmSnapshotIndex, PatchOperation, PatchOperationResult, PatchOperationType, PatchPlan, PatchPlanRun, PatchPlanRunStatus, PatchVerification, PipelineFinding, PipelineFindingStatus, PipelineFindingType, ProviderIdentity, RiskLevel, SourceFreshness, } from "./types.ts";

package/dist/index.js

@@ -14,8 +14,11 @@ export { createFilePlanStore } from "./planStore.js";
 export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.js";
 export { auditReportToHtml, auditReportToMarkdown } from "./report.js";
 export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, } from "./mappings.js";
-export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, requiresHumanInput, staleDealRule, } from "./rules.js";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.js";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, } from "./calls.js";
 export { sampleSnapshot } from "./sampleData.js";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
+export { resolveRecord } from "./resolve.js";
+export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadMarketConfig, marketHome, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, } from "./market.js";
+export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 export { suggestValues } from "./suggest.js";

package/dist/market.d.ts

@@ -0,0 +1,147 @@
+import type { GtmEvidence } from "./types.ts";
+/**
+ * The Market Map: a live model of the competitive category a company sells
+ * into. Vendors publish claims constantly (pricing pages, feature pages,
+ * hero copy); each (vendor × claim) cell gets a messaging-intensity reading,
+ * and each claim row gets a derived front state. Observations are
+ * append-only — history is the product; "what changed since last run" is a
+ * first-class question.
+ *
+ * Division of labor mirrors call intelligence: intensity readings are
+ * *proposals* (LLM or human, always with verbatim quoted evidence), while
+ * everything downstream — front states, drift, the report — is deterministic
+ * over the stored observations. Same stored observations, same map.
+ *
+ * The claim taxonomy and vendor registry live in a reviewable config file
+ * (git-friendly, analyst-edited); captures and observations live under the
+ * profile home so one client's category intel never bleeds into another's.
+ */
+export type ClaimIntensity = "loud" | "quiet" | "absent" | "unobservable";
+export type ObservationConfidence = "high" | "medium" | "low";
+export type FrontState = "open" | "contested" | "owned" | "saturated" | "vacant";
+export type MarketClaim = {
+    id: string;
+    /** The capability being claimed, precise enough to judge loud/quiet/absent. */
+    capability: string;
+    /** Which ICP the claim cell addresses (category-specific vocabulary). */
+    icp: string;
+    /** Which pricing structure the claim cell implies (category-specific). */
+    pricingStructure: string;
+    /** Operational definition: how a reader judges LOUD vs QUIET vs ABSENT. */
+    definition: string;
+};
+export type MarketVendor = {
+    id: string;
+    name: string;
+    urls: {
+        home: string;
+        /** null is itself an observation: no public pricing surface. */
+        pricing: string | null;
+        product: string[];
+    };
+    notes?: string;
+};
+export type MarketConfig = {
+    category: string;
+    anchorVendor?: string;
+    vendors: MarketVendor[];
+    claims: MarketClaim[];
+    /** The LOUD/QUIET/ABSENT/UNOBSERVABLE judging rule, stated for reviewers. */
+    surfaceRule?: string;
+};
+export type MarketObservation = {
+    /** stableHash(category, runLabel, vendorId, claimId) — deterministic. */
+    id: string;
+    vendorId: string;
+    claimId: string;
+    observedAt: string;
+    intensity: ClaimIntensity;
+    confidence: ObservationConfidence;
+    /** Reviewer-facing: why the reading is what it is. */
+    reason: string;
+    /**
+     * Verbatim quoted spans grounding any non-absent reading
+     * (sourceSystem "web", metadata.url + metadata.captureHash).
+     */
+    evidence: GtmEvidence[];
+};
+export type ObservationSet = {
+    id: string;
+    category: string;
+    runLabel: string;
+    runAt: string;
+    /** What produced the readings: "manual" or "llm:<provider>:<model>". */
+    extractor: string;
+    observations: MarketObservation[];
+};
+export type CaptureEntry = {
+    runLabel: string;
+    vendorId: string;
+    kind: "home" | "pricing" | "product";
+    url: string;
+    fetchedAt: string;
+    httpStatus: number | null;
+    /** sha256 of the extracted text; null when the fetch failed or was empty. */
+    captureHash: string | null;
+    textChars: number;
+};
+export declare function observationId(category: string, runLabel: string, vendorId: string, claimId: string): string;
+export declare function parseMarketConfig(raw: string): MarketConfig;
+export declare function loadMarketConfig(path: string): MarketConfig;
+export declare function starterMarketConfig(category: string): MarketConfig;
+export declare function marketHome(category: string, baseDir?: string): string;
+export declare function extractReadableText(html: string): string;
+export type FetchPage = (url: string) => Promise<{
+    status: number;
+    body: string;
+}>;
+export type CaptureOptions = {
+    /** Directory for captures; defaults to <marketHome>/captures. */
+    dir?: string;
+    runLabel?: string;
+    /** Injectable for tests; defaults to global fetch. */
+    fetchPage?: FetchPage;
+    now?: () => Date;
+};
+export type CaptureResult = {
+    entries: CaptureEntry[];
+    manifestPath: string;
+};
+export declare function captureMarket(config: MarketConfig, options?: CaptureOptions): Promise<CaptureResult>;
+export interface ObservationStore {
+    append(set: ObservationSet): Promise<ObservationSet>;
+    get(runLabel: string): Promise<ObservationSet | null>;
+    list(): Promise<Array<{
+        runLabel: string;
+        runAt: string;
+        observations: number;
+    }>>;
+    latest(): Promise<ObservationSet | null>;
+}
+export declare function createFileObservationStore(category: string, directory?: string): ObservationStore;
+/**
+ * Validate a proposed observation set against the config before it enters
+ * the store: known vendors/claims, full coverage, legal readings, and the
+ * verbatim-evidence rule (non-absent readings must quote something).
+ * Returns problems; an empty array means accept.
+ */
+export declare function validateObservationSet(config: MarketConfig, set: ObservationSet): string[];
+export type ClaimFront = {
+    claimId: string;
+    state: FrontState;
+    loudVendorIds: string[];
+    quietVendorIds: string[];
+};
+/**
+ * Front rule v1: 0 loud → open (if anyone is quiet) or vacant; 1 loud →
+ * owned; 2–3 loud → contested; ≥4 loud → saturated. Unobservable cells are
+ * excluded — a failed capture never reads as absence.
+ */
+export declare function computeFrontStates(config: MarketConfig, set: ObservationSet): ClaimFront[];
+export type FrontDrift = {
+    claimId: string;
+    before: FrontState;
+    after: FrontState;
+};
+/** What changed in the category between two runs — the refresh's whole point. */
+export declare function diffFrontStates(before: ClaimFront[], after: ClaimFront[]): FrontDrift[];