fullstackgtm 0.14.1 → 0.16.0

package/dist/market.js

@@ -0,0 +1,319 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { credentialsDir } from "./credentials.js";
+const INTENSITY_RANK = {
+    loud: 3,
+    quiet: 2,
+    absent: 1,
+    unobservable: 0,
+};
+// Mirrors stableHash in rules.ts (FNV-1a); duplicated to keep market.ts
+// importable without pulling the audit engine.
+function fnv1a(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+export function observationId(category, runLabel, vendorId, claimId) {
+    return `obs_${fnv1a(`${category}|${runLabel}|${vendorId}|${claimId}`)}`;
+}
+// ---------------------------------------------------------------------------
+// Config
+export function parseMarketConfig(raw) {
+    const config = JSON.parse(raw);
+    if (!config.category)
+        throw new Error("market config: missing category");
+    if (!Array.isArray(config.vendors) || config.vendors.length === 0) {
+        throw new Error("market config: at least one vendor is required");
+    }
+    if (!Array.isArray(config.claims) || config.claims.length === 0) {
+        throw new Error("market config: at least one claim is required");
+    }
+    for (const [label, items] of [
+        ["vendor", config.vendors],
+        ["claim", config.claims],
+    ]) {
+        const seen = new Set();
+        for (const item of items) {
+            if (!item.id)
+                throw new Error(`market config: ${label} missing id`);
+            if (seen.has(item.id))
+                throw new Error(`market config: duplicate ${label} id "${item.id}"`);
+            seen.add(item.id);
+        }
+    }
+    if (config.anchorVendor && !config.vendors.some((v) => v.id === config.anchorVendor)) {
+        throw new Error(`market config: anchorVendor "${config.anchorVendor}" is not in vendors`);
+    }
+    return config;
+}
+export function loadMarketConfig(path) {
+    return parseMarketConfig(readFileSync(path, "utf8"));
+}
+export function starterMarketConfig(category) {
+    return {
+        category,
+        anchorVendor: "your-company",
+        vendors: [
+            {
+                id: "your-company",
+                name: "Your Company",
+                urls: { home: "https://example.com/", pricing: null, product: [] },
+                notes: "Replace with the real vendor set (≤10 works well). pricing: null records 'no public pricing page'.",
+            },
+        ],
+        claims: [
+            {
+                id: "example-claim",
+                capability: "Example capability: what is being claimed, stated precisely",
+                icp: "who-buys-it",
+                pricingStructure: "how-it-is-priced",
+                definition: "LOUD if the claim is hero copy or a top-nav named product with a dedicated page; QUIET if it appears only on pages below that; ABSENT if nowhere. Write the definition so a human could judge any vendor's page against it.",
+            },
+        ],
+        surfaceRule: "LOUD = hero copy OR top-level-nav named product with dedicated page; QUIET = present on any indexed page below that; ABSENT = nowhere observed (explicit disavowals score ABSENT with the disavowal quoted in reason); UNOBSERVABLE = capture empty/failed — never score ABSENT from a failed capture.",
+    };
+}
+// ---------------------------------------------------------------------------
+// Profile-scoped market home: captures and observations live with credentials
+// so --profile isolation covers category intel too.
+export function marketHome(category, baseDir) {
+    return join(baseDir ?? credentialsDir(), "market", category);
+}
+// ---------------------------------------------------------------------------
+// Capture: fetch vendor pages, strip to readable text, store content-addressed.
+// The hash cache is the change detector (unchanged page = same hash = no new
+// classification needed), the replay buffer (re-judge a revised taxonomy
+// without re-scraping), and the evidence chain (quoted spans stay resolvable).
+const STRIP_BLOCKS = /<(script|style|noscript|svg|head)\b[\s\S]*?<\/\1\s*>/gi;
+const ENTITIES = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&mdash;": "—",
+    "&ndash;": "–",
+};
+export function extractReadableText(html) {
+    const withoutBlocks = html.replace(STRIP_BLOCKS, " ");
+    const withBreaks = withoutBlocks.replace(/<(\/p|\/div|\/li|\/h[1-6]|br\s*\/?)>/gi, "\n");
+    const withoutTags = withBreaks.replace(/<[^>]+>/g, " ");
+    const decoded = withoutTags
+        .replace(/&[a-z#0-9]+;/gi, (entity) => ENTITIES[entity.toLowerCase()] ?? " ")
+        .replace(/[ \t]+/g, " ");
+    return decoded
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+const defaultFetchPage = async (url) => {
+    const response = await fetch(url, {
+        headers: {
+            "User-Agent": "fullstackgtm-market/0 (+https://github.com/fullstackgtm/core)",
+            "Accept-Language": "en-US",
+        },
+        redirect: "follow",
+    });
+    return { status: response.status, body: await response.text() };
+};
+export async function captureMarket(config, options = {}) {
+    const dir = options.dir ?? join(marketHome(config.category), "captures");
+    const runLabel = options.runLabel ?? "run-1";
+    const fetchPage = options.fetchPage ?? defaultFetchPage;
+    const fetchedAt = (options.now ?? (() => new Date()))().toISOString();
+    mkdirSync(dir, { recursive: true });
+    const manifestPath = join(dir, "manifest.json");
+    const manifest = existsSync(manifestPath)
+        ? JSON.parse(readFileSync(manifestPath, "utf8"))
+        : [];
+    const entries = [];
+    for (const vendor of config.vendors) {
+        const targets = [
+            { kind: "home", url: vendor.urls.home },
+        ];
+        if (vendor.urls.pricing)
+            targets.push({ kind: "pricing", url: vendor.urls.pricing });
+        for (const url of vendor.urls.product)
+            targets.push({ kind: "product", url });
+        for (const target of targets) {
+            let status = null;
+            let text = "";
+            try {
+                const page = await fetchPage(target.url);
+                status = page.status;
+                if (page.status === 200)
+                    text = extractReadableText(page.body);
+            }
+            catch {
+                status = null;
+            }
+            let captureHash = null;
+            if (text) {
+                captureHash = createHash("sha256").update(text).digest("hex");
+                // Content-addressed: an unchanged page dedupes to the same file.
+                writeFileSync(join(dir, `${captureHash}.txt`), text);
+            }
+            const entry = {
+                runLabel,
+                vendorId: vendor.id,
+                kind: target.kind,
+                url: target.url,
+                fetchedAt,
+                httpStatus: status,
+                captureHash,
+                textChars: text.length,
+            };
+            manifest.push(entry);
+            entries.push(entry);
+        }
+    }
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return { entries, manifestPath };
+}
+export function createFileObservationStore(category, directory) {
+    const dir = directory ?? join(marketHome(category), "observations");
+    function fileFor(runLabel) {
+        if (!/^[\w.-]+$/.test(runLabel))
+            throw new Error(`Invalid run label: ${runLabel}`);
+        return join(dir, `${runLabel}.json`);
+    }
+    function read(runLabel) {
+        try {
+            return JSON.parse(readFileSync(fileFor(runLabel), "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    function listSets() {
+        let names = [];
+        try {
+            names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+        }
+        catch {
+            return [];
+        }
+        return names
+            .map((name) => read(name.replace(/\.json$/, "")))
+            .filter((set) => set !== null)
+            .sort((a, b) => a.runAt.localeCompare(b.runAt));
+    }
+    return {
+        async append(set) {
+            if (set.category !== category) {
+                throw new Error(`Observation set category "${set.category}" does not match store "${category}"`);
+            }
+            if (read(set.runLabel)) {
+                throw new Error(`Run "${set.runLabel}" already exists — observations are append-only; use a new run label`);
+            }
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(fileFor(set.runLabel), `${JSON.stringify(set, null, 2)}\n`);
+            return set;
+        },
+        async get(runLabel) {
+            return read(runLabel);
+        },
+        async list() {
+            return listSets().map((set) => ({
+                runLabel: set.runLabel,
+                runAt: set.runAt,
+                observations: set.observations.length,
+            }));
+        },
+        async latest() {
+            const sets = listSets();
+            return sets.length ? sets[sets.length - 1] : null;
+        },
+    };
+}
+/**
+ * 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 function validateObservationSet(config, set) {
+    const problems = [];
+    const vendorIds = new Set(config.vendors.map((v) => v.id));
+    const claimIds = new Set(config.claims.map((c) => c.id));
+    const seen = new Set();
+    for (const obs of set.observations) {
+        const cell = `${obs.vendorId} × ${obs.claimId}`;
+        if (!vendorIds.has(obs.vendorId))
+            problems.push(`unknown vendor "${obs.vendorId}"`);
+        if (!claimIds.has(obs.claimId))
+            problems.push(`unknown claim "${obs.claimId}"`);
+        if (seen.has(cell))
+            problems.push(`duplicate observation for ${cell}`);
+        seen.add(cell);
+        if (!INTENSITY_RANK[obs.intensity] && obs.intensity !== "unobservable") {
+            problems.push(`${cell}: invalid intensity "${obs.intensity}"`);
+        }
+        if ((obs.intensity === "loud" || obs.intensity === "quiet") && obs.evidence.length === 0) {
+            problems.push(`${cell}: ${obs.intensity} reading with no quoted evidence`);
+        }
+    }
+    for (const vendor of config.vendors) {
+        for (const claim of config.claims) {
+            if (!seen.has(`${vendor.id} × ${claim.id}`)) {
+                problems.push(`missing observation for ${vendor.id} × ${claim.id}`);
+            }
+        }
+    }
+    return problems;
+}
+/**
+ * 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 function computeFrontStates(config, set) {
+    const byCell = new Map();
+    for (const obs of set.observations) {
+        const key = `${obs.vendorId}|${obs.claimId}`;
+        const existing = byCell.get(key);
+        if (!existing || INTENSITY_RANK[obs.intensity] > INTENSITY_RANK[existing.intensity]) {
+            byCell.set(key, obs);
+        }
+    }
+    return config.claims.map((claim) => {
+        const loud = [];
+        const quiet = [];
+        for (const vendor of config.vendors) {
+            const obs = byCell.get(`${vendor.id}|${claim.id}`);
+            if (obs?.intensity === "loud")
+                loud.push(vendor.id);
+            if (obs?.intensity === "quiet")
+                quiet.push(vendor.id);
+        }
+        let state;
+        if (loud.length === 0)
+            state = quiet.length >= 1 ? "open" : "vacant";
+        else if (loud.length === 1)
+            state = "owned";
+        else if (loud.length <= 3)
+            state = "contested";
+        else
+            state = "saturated";
+        return { claimId: claim.id, state, loudVendorIds: loud, quietVendorIds: quiet };
+    });
+}
+/** What changed in the category between two runs — the refresh's whole point. */
+export function diffFrontStates(before, after) {
+    const prior = new Map(before.map((front) => [front.claimId, front.state]));
+    const drift = [];
+    for (const front of after) {
+        const was = prior.get(front.claimId);
+        if (was && was !== front.state)
+            drift.push({ claimId: front.claimId, before: was, after: front.state });
+    }
+    return drift;
+}

package/dist/marketReport.d.ts

@@ -0,0 +1,3 @@
+import type { MarketConfig, ObservationSet } from "./market.ts";
+export declare function marketMapToMarkdown(config: MarketConfig, set: ObservationSet): string;
+export declare function marketMapToHtml(config: MarketConfig, set: ObservationSet): string;

package/dist/marketReport.js

@@ -0,0 +1,233 @@
+import { computeFrontStates } from "./market.js";
+/**
+ * Render a market map as a client-ready deliverable: markdown for terminals
+ * and PRs, and a self-contained printable HTML "field report" — front
+ * summary, claim × vendor intensity matrix, and a verbatim-evidence
+ * appendix. Deterministic: same observation set, same bytes. No webfonts,
+ * no CDNs — the artifact must stand alone wherever it's sent.
+ */
+const FRONT_ORDER = {
+    open: 0,
+    contested: 1,
+    owned: 2,
+    saturated: 3,
+    vacant: 4,
+};
+const GLYPH = {
+    loud: "■",
+    quiet: "□",
+    absent: "·",
+    unobservable: "▨",
+};
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function buildModel(config, set) {
+    const fronts = computeFrontStates(config, set);
+    const stateByClaim = new Map(fronts.map((front) => [front.claimId, front.state]));
+    const orderedClaimIds = config.claims
+        .map((claim) => claim.id)
+        .sort((a, b) => {
+        const byFront = FRONT_ORDER[stateByClaim.get(a) ?? "vacant"] - FRONT_ORDER[stateByClaim.get(b) ?? "vacant"];
+        return byFront !== 0 ? byFront : a.localeCompare(b);
+    });
+    const byCell = new Map(set.observations.map((obs) => [`${obs.vendorId}|${obs.claimId}`, obs]));
+    return {
+        config,
+        set,
+        fronts,
+        orderedClaimIds,
+        cell: (vendorId, claimId) => byCell.get(`${vendorId}|${claimId}`),
+    };
+}
+export function marketMapToMarkdown(config, set) {
+    const model = buildModel(config, set);
+    const stateByClaim = new Map(model.fronts.map((front) => [front.claimId, front.state]));
+    const counts = { open: 0, contested: 0, owned: 0, saturated: 0, vacant: 0 };
+    for (const front of model.fronts)
+        counts[front.state] += 1;
+    const lines = [];
+    lines.push(`# Market map — ${config.category} (${set.runLabel})`);
+    lines.push("");
+    lines.push(`Observed ${set.runAt} · ${config.vendors.length} vendors · ${config.claims.length} claims · ` +
+        `${set.observations.length} readings · extractor ${set.extractor}`);
+    lines.push("");
+    lines.push(`Fronts: ${counts.open + counts.vacant} open/vacant · ${counts.contested} contested · ` +
+        `${counts.owned} owned · ${counts.saturated} saturated`);
+    lines.push("");
+    lines.push(`Legend: ■ loud · □ quiet · · absent · ▨ unobservable`);
+    lines.push("");
+    const header = ["claim", ...config.vendors.map((v) => v.id), "front"];
+    lines.push(`| ${header.join(" | ")} |`);
+    lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+    for (const claimId of model.orderedClaimIds) {
+        const cells = config.vendors.map((vendor) => GLYPH[model.cell(vendor.id, claimId)?.intensity ?? "unobservable"]);
+        lines.push(`| ${claimId} | ${cells.join(" | ")} | ${stateByClaim.get(claimId)?.toUpperCase()} |`);
+    }
+    lines.push("");
+    for (const front of model.fronts.filter((f) => f.state === "owned")) {
+        lines.push(`- OWNED: ${front.claimId} → ${front.loudVendorIds[0]}`);
+    }
+    for (const front of model.fronts.filter((f) => f.state === "open" || f.state === "vacant")) {
+        lines.push(`- ${front.state.toUpperCase()}: ${front.claimId} — no vendor is loud here`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function marketMapToHtml(config, set) {
+    const model = buildModel(config, set);
+    const stateByClaim = new Map(model.fronts.map((front) => [front.claimId, front.state]));
+    const claimsById = new Map(config.claims.map((claim) => [claim.id, claim]));
+    const counts = { open: 0, contested: 0, owned: 0, saturated: 0, vacant: 0 };
+    for (const front of model.fronts)
+        counts[front.state] += 1;
+    const unobservable = set.observations.filter((obs) => obs.intensity === "unobservable").length;
+    const anchor = config.anchorVendor;
+    const e = escapeHtml;
+    const matrixRows = model.orderedClaimIds
+        .map((claimId) => {
+        const claim = claimsById.get(claimId);
+        if (!claim)
+            return "";
+        const state = stateByClaim.get(claimId) ?? "vacant";
+        const cells = config.vendors
+            .map((vendor) => {
+            const intensity = model.cell(vendor.id, claimId)?.intensity ?? "unobservable";
+            const anchorClass = vendor.id === anchor ? " anchor-col" : "";
+            return `<td class="cell${anchorClass}"><span class="g g-${intensity}" title="${e(vendor.name)}: ${intensity}"></span></td>`;
+        })
+            .join("");
+        return (`<tr class="front-${state}"><th scope="row"><span class="claim-cap">${e(claim.capability.split(":")[0])}</span>` +
+            `<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>`);
+    })
+        .join("");
+    const openList = model.orderedClaimIds
+        .filter((claimId) => {
+        const state = stateByClaim.get(claimId);
+        return state === "open" || state === "vacant";
+    })
+        .map((claimId) => {
+        const claim = claimsById.get(claimId);
+        return `<li><b>${e(claim?.capability.split(":")[0] ?? claimId)}</b> <span class="why">— no vendor is loud here; ${e(claim?.icp ?? "")} cell</span></li>`;
+    })
+        .join("");
+    const appendix = model.orderedClaimIds
+        .flatMap((claimId) => config.vendors.flatMap((vendor) => {
+        const obs = model.cell(vendor.id, claimId);
+        if (!obs || obs.evidence.length === 0)
+            return [];
+        return obs.evidence.map((evidence) => `<div class="ev"><span class="ev-head">${e(vendor.name)} · ${e(claimId)} · ${obs.intensity.toUpperCase()} (${obs.confidence})</span>` +
+            `<blockquote>“${e(evidence.text)}”</blockquote>` +
+            `<span class="ev-src">${e(String(evidence.metadata?.url ?? ""))} · capture ${e(String(evidence.metadata?.captureHash ?? "").slice(0, 12))}</span></div>`);
+    }))
+        .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">
+<title>Market map — ${e(config.category)} — ${e(set.runLabel)}</title>
+<style>
+:root { --paper:#f4efe4; --ink:#211d16; --ink-soft:#5a5244; --line:#c9bfa9; --accent:#b4441b; --green:#2e5339; --quiet:#8a7d63; }
+* { box-sizing:border-box; margin:0; }
+body { font-family:"Iowan Old Style","Palatino Linotype",Palatino,Georgia,serif; color:var(--ink); background:var(--paper);
+  max-width:1080px; margin:0 auto; padding:0 48px 96px;
+  background-image:radial-gradient(rgba(33,29,22,.028) 1px, transparent 1.2px); background-size:5px 5px; }
+.chip,.claim-meta,.ev-src,.lg,.stamp,.meta,th.vh span { font-family:"SF Mono",Menlo,Consolas,monospace; }
+header { padding:56px 0 28px; border-bottom:3px double var(--ink); position:relative; }
+.kicker { font-size:11px; letter-spacing:.32em; color:var(--accent); text-transform:uppercase; }
+h1 { font-size:44px; line-height:1.05; font-weight:600; margin:10px 0 6px; }
+h1 em { font-style:italic; color:var(--green); }
+.meta { font-size:11.5px; color:var(--ink-soft); display:flex; gap:24px; flex-wrap:wrap; margin-top:14px; }
+.stamp { position:absolute; right:0; top:58px; border:2px solid var(--accent); color:var(--accent); padding:7px 13px;
+  font-size:11px; letter-spacing:.22em; transform:rotate(3.5deg); text-transform:uppercase; }
+section { margin-top:56px; }
+h2 { font-size:13px; letter-spacing:.26em; text-transform:uppercase; color:var(--ink-soft);
+  border-bottom:1px solid var(--line); padding-bottom:9px; display:flex; gap:14px; align-items:baseline; }
+h2 .no { color:var(--accent); font-style:italic; font-size:15px; letter-spacing:0; }
+.fronts { display:grid; grid-template-columns:repeat(4,1fr); gap:1px; background:var(--line); border:1px solid var(--line); margin-top:22px; }
+.fcard { background:var(--paper); padding:18px 18px 14px; }
+.fcard b { display:block; font-size:42px; font-weight:600; line-height:1; }
+.fcard span { font-size:11px; letter-spacing:.18em; text-transform:uppercase; color:var(--ink-soft); }
+.fcard.open b { color:var(--accent); }
+.openlist { margin-top:18px; font-size:15.5px; line-height:1.55; }
+.openlist li { margin:4px 0 4px 20px; }
+.openlist .why { color:var(--ink-soft); font-size:13px; font-style:italic; }
+.legend { display:flex; gap:22px; flex-wrap:wrap; margin:18px 0 10px; font-size:10.5px; color:var(--ink-soft); }
+.lg { display:inline-flex; align-items:center; gap:7px; }
+table { border-collapse:collapse; width:100%; margin-top:6px; }
+thead th { border-bottom:2px solid var(--ink); padding:6px 2px 10px; }
+th.vh span { writing-mode:vertical-rl; transform:rotate(195deg); font-size:10.5px; letter-spacing:.12em;
+  text-transform:uppercase; color:var(--ink-soft); display:inline-block; }
+th.vh.anchor-col span { color:var(--green); font-weight:700; }
+tbody th { text-align:left; font-weight:400; padding:7px 14px 7px 0; border-bottom:1px solid var(--line); max-width:330px; }
+.claim-cap { display:block; font-size:14.5px; }
+.claim-meta { display:block; font-size:9.5px; color:var(--quiet); letter-spacing:.08em; margin-top:2px; }
+td.cell { text-align:center; border-bottom:1px solid var(--line); padding:4px 2px; }
+td.cell.anchor-col { background:rgba(46,83,57,.06); }
+td.front { border-bottom:1px solid var(--line); text-align:right; white-space:nowrap; }
+.g { display:inline-block; width:15px; height:15px; vertical-align:middle; }
+.g-loud { background:var(--ink); }
+.g-quiet { box-shadow:inset 0 0 0 2px var(--quiet); }
+.g-absent { background:radial-gradient(circle at center, var(--line) 0 2.5px, transparent 3px); }
+.g-unobservable { background:repeating-linear-gradient(45deg, var(--line) 0 2px, transparent 2px 5px); }
+tr.front-open th .claim-cap { color:var(--accent); font-weight:600; }
+.chip { font-size:9px; letter-spacing:.16em; padding:3px 8px; border:1px solid currentColor; }
+.chip-open { color:var(--accent); } .chip-contested { color:#7a5a12; }
+.chip-owned { color:var(--green); } .chip-saturated { color:var(--ink-soft); } .chip-vacant { color:var(--quiet); }
+.ev { border-bottom:1px solid var(--line); padding:12px 0; }
+.ev-head { font-size:10.5px; letter-spacing:.1em; color:var(--accent); }
+.ev blockquote { font-style:italic; margin:6px 0; font-size:13.5px; line-height:1.5; }
+.ev-src { font-size:10px; color:var(--ink-soft); word-break:break-all; }
+footer { margin-top:72px; border-top:3px double var(--ink); padding-top:14px; font-size:11px; color:var(--ink-soft);
+  display:flex; justify-content:space-between; gap:20px; flex-wrap:wrap; }
+@media print { body { max-width:none; padding:0 8mm; background:white; } section { break-inside:avoid-page; } tr { break-inside:avoid; } }
+</style></head><body>
+<header>
+  <div class="kicker">Full Stack GTM · Market Map</div>
+  <h1>The <em>${e(config.category.replace(/-/g, " "))}</em> front map</h1>
+  <div class="meta">
+    <span>RUN ${e(set.runLabel.toUpperCase())}</span><span>OBSERVED ${e(set.runAt)}</span>
+    <span>${config.vendors.length} VENDORS · ${config.claims.length} CLAIMS · ${set.observations.length} READINGS</span>
+    <span>${unobservable} UNOBSERVABLE · EXTRACTOR ${e(set.extractor)}</span>
+  </div>
+  <div class="stamp">Field Report</div>
+</header>
+<section>
+  <h2><span class="no">01</span> Front summary</h2>
+  <div class="fronts">
+    <div class="fcard open"><b>${counts.open + counts.vacant}</b><span>Open / vacant</span></div>
+    <div class="fcard"><b>${counts.contested}</b><span>Contested</span></div>
+    <div class="fcard"><b>${counts.owned}</b><span>Owned</span></div>
+    <div class="fcard"><b>${counts.saturated}</b><span>Saturated</span></div>
+  </div>
+  <ul class="openlist">${openList}</ul>
+</section>
+<section>
+  <h2><span class="no">02</span> Claim × vendor intensity matrix</h2>
+  <div class="legend">
+    <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>
+    <span class="lg"><i class="g g-absent"></i>ABSENT</span>
+    <span class="lg"><i class="g g-unobservable"></i>UNOBSERVABLE — capture failed</span>
+  </div>
+  <table>
+    <thead><tr><th></th>${vendorHeads}<th></th></tr></thead>
+    <tbody>${matrixRows}</tbody>
+  </table>
+</section>
+<section>
+  <h2><span class="no">03</span> Evidence appendix</h2>
+  ${appendix}
+</section>
+<footer>
+  <span>Generated by fullstackgtm market · deterministic render of ${e(set.runLabel)}</span>
+  <span>Front rule v1: 0 loud=open · 1=owned · 2–3=contested · ≥4=saturated</span>
+</footer>
+</body></html>`;
+}

package/dist/mcp.js

@@ -47,6 +47,7 @@ import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall } from "./calls.js";
 import { extractInsightsLlm, resolveLlmCredential } from "./llm.js";
+import { resolveRecord } from "./resolve.js";
 import { suggestValues } from "./suggest.js";
 function content(value) {
     return {
@@ -197,6 +198,25 @@ export async function startMcpServer() {
         }
         return content(parseCall(raw, { title, sourceSystem: source }));
     });
+    server.registerTool("fullstackgtm_resolve", {
+        title: "Resolve Record (create gate)",
+        description: "Before creating a CRM record, check whether it already exists. Returns a verdict " +
+            "(exists | ambiguous | safe_to_create) with matches and a reason, using the same " +
+            "identity keys as the audit/merge engines (account domain, contact email, open-deal " +
+            "key). Read-only. Never create on 'exists' or 'ambiguous'.",
+        inputSchema: {
+            objectType: z.enum(["account", "contact", "deal"]),
+            name: z.string().optional(),
+            domain: z.string().optional(),
+            email: z.string().optional(),
+            accountId: z.string().optional(),
+            provider: z.enum(["sample", "demo", "hubspot", "salesforce", "stripe"]).optional(),
+            inputPath: z.string().optional(),
+        },
+    }, async ({ objectType, name, domain, email, accountId, provider, inputPath }) => {
+        const snapshot = await readSnapshot(provider, inputPath);
+        return content(resolveRecord(snapshot, { objectType, name, domain, email, accountId }));
+    });
     server.registerTool("fullstackgtm_rules", {
         title: "List Audit Rules",
         description: "List the built-in deterministic audit rules with ids and descriptions.",

package/dist/merge.js

@@ -1,5 +1,5 @@
 const CONFLICT_IGNORED_FIELDS = new Set([
-    "id", "provider", "crmId", "identities", "raw", "lastSyncAt", "lastActivityAt", "ownerId", "accountId",
+    "id", "provider", "crmId", "identities", "raw", "lastSyncAt", "lastActivityAt", "ownerId", "accountId", "provenance",
 ]);
 export function normalizeDomain(domain) {
     if (!domain)

package/dist/resolve.d.ts

@@ -0,0 +1,37 @@
+import type { CanonicalGtmSnapshot } from "./types.ts";
+/**
+ * The resolve gate — the Prevent layer of the CRM-health lifecycle.
+ *
+ * Before any writer (sync job, webhook handler, agent, this CLI's own
+ * `create:` path) creates a record, it should ask: does this record already
+ * exist? The gate answers deterministically from a snapshot using the same
+ * identity keys the audit and merge engines use:
+ *
+ *   account → normalized domain (exact), then normalized name
+ *   contact → normalized email (exact), then full name
+ *   deal    → open-deal key: (accountId | "unlinked") + normalized name
+ *
+ * Verdicts are gate-shaped: `exists` (link to it, don't create),
+ * `ambiguous` (a human must pick — do NOT blind-create), `safe_to_create`.
+ */
+export type ResolveCandidate = {
+    objectType: "account" | "contact" | "deal";
+    name?: string;
+    domain?: string;
+    email?: string;
+    /** For deals: scope the duplicate key to an account. */
+    accountId?: string;
+};
+export type ResolveMatch = {
+    id: string;
+    name: string;
+    matchedBy: "domain" | "email" | "name" | "deal_key";
+    detail: string;
+};
+export type ResolveResult = {
+    objectType: ResolveCandidate["objectType"];
+    verdict: "exists" | "ambiguous" | "safe_to_create";
+    matches: ResolveMatch[];
+    reason: string;
+};
+export declare function resolveRecord(snapshot: CanonicalGtmSnapshot, candidate: ResolveCandidate): ResolveResult;