fullstackgtm 0.15.0 → 0.17.0

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,8 @@ import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall } from "./calls.js";
 import { extractInsightsLlm, resolveLlmCredential } from "./llm.js";
+import { computeFrontStates, createFileObservationStore, loadCaptureTexts, loadMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
+import { buildWorksheet } from "./marketClassify.js";
 import { resolveRecord } from "./resolve.js";
 import { suggestValues } from "./suggest.js";
 function content(value) {
@@ -244,6 +246,49 @@ export async function startMcpServer() {
         });
         return content(output === "markdown" ? formatPatchPlanRun(run) : run);
     });
+    server.registerTool("fullstackgtm_market_worksheet", {
+        title: "Market Map Classification Worksheet",
+        description: "Get everything needed to classify ONE vendor's messaging intensity for a market map: " +
+            "the claim taxonomy with judging definitions, the surface rule, and the captured page " +
+            "texts. Read each claim's definition, judge loud/quiet/absent from the page texts only, " +
+            "and quote verbatim spans (≤300 chars) for every loud/quiet reading. Submit the full " +
+            "ObservationSet via fullstackgtm_market_observe — quotes are verified character-for-" +
+            "character against the captures, so never paraphrase.",
+        inputSchema: {
+            vendorId: z.string(),
+            configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
+            captureRun: z.string().optional(),
+        },
+    }, async ({ vendorId, configPath, captureRun }) => {
+        const config = loadMarketConfig(resolve(process.cwd(), configPath ?? "market.config.json"));
+        return content(buildWorksheet(config, vendorId, { captureRun }));
+    });
+    server.registerTool("fullstackgtm_market_observe", {
+        title: "Submit Market Map Observations",
+        description: "Submit a complete ObservationSet (every vendor × claim cell) for a market map run. " +
+            "Validates coverage, the verbatim-evidence rule, and mechanically verifies every quoted " +
+            "span against the stored capture it cites. Returns problems if rejected; nothing is " +
+            "stored unless the whole set passes. Observations are append-only — use a new runLabel.",
+        inputSchema: {
+            observationsPath: z.string().describe("Path to the ObservationSet JSON file"),
+            configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
+        },
+    }, async ({ observationsPath, configPath }) => {
+        const config = loadMarketConfig(resolve(process.cwd(), configPath ?? "market.config.json"));
+        const set = JSON.parse(readFileSync(resolve(process.cwd(), observationsPath), "utf8"));
+        const problems = validateObservationSet(config, set);
+        const failures = verifyEvidenceSpans(set.observations, loadCaptureTexts(config.category).textByHash);
+        if (problems.length > 0 || failures.length > 0) {
+            return content({
+                accepted: false,
+                problems,
+                spanFailures: failures.map((failure) => `${failure.vendorId} × ${failure.claimId}: ${failure.problem}`),
+            });
+        }
+        await createFileObservationStore(config.category).append(set);
+        const fronts = computeFrontStates(config, set);
+        return content({ accepted: true, runLabel: set.runLabel, observations: set.observations.length, fronts });
+    });
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/resolve.js

@@ -73,28 +73,47 @@ function resolveDeal(snapshot, c) {
     if (!c.name) {
         return { ...base, verdict: "ambiguous", matches: [], reason: "Supply --name (and ideally --account-id) to resolve a deal." };
     }
-    const key = `${c.accountId ?? "unlinked"}:${normalizeName(c.name)}`;
+    const nameKey = normalizeName(c.name);
     const open = snapshot.deals.filter((d) => d.isClosed !== true && d.isWon !== true);
-    const matches = open
-        .filter((d) => `${d.accountId ?? "unlinked"}:${normalizeName(d.name)}` === key)
-        .map((d) => match(d.id, d.name, "deal_key", `open deal with the same name on ${c.accountId ? `account ${c.accountId}` : "no account"}`));
-    if (matches.length > 0) {
+    if (c.accountId) {
+        const key = `${c.accountId}:${nameKey}`;
+        const matches = open
+            .filter((d) => `${d.accountId ?? "unlinked"}:${normalizeName(d.name)}` === key)
+            .map((d) => match(d.id, d.name, "deal_key", `open deal with the same name on account ${c.accountId}`));
+        if (matches.length > 0) {
+            return {
+                ...base,
+                verdict: "exists",
+                matches,
+                reason: `${matches.length} open deal(s) already match "${c.name}" on account ${c.accountId} — creating another would double-count pipeline. Update the existing deal.`,
+            };
+        }
+        const closedSameName = snapshot.deals.filter((d) => (d.isClosed === true || d.isWon === true) &&
+            d.accountId === c.accountId &&
+            normalizeName(d.name) === nameKey);
+        return {
+            ...base,
+            verdict: "safe_to_create",
+            matches: [],
+            reason: closedSameName.length > 0
+                ? `No open deal matches on account ${c.accountId}; ${closedSameName.length} closed deal(s) on it share the name (a re-open/renewal may be intended). Safe to create.`
+                : `No open deal matches "${c.name}" on account ${c.accountId}. Safe to create.`,
+        };
+    }
+    // No account scope: name-only matches across ALL open deals are ambiguous,
+    // never safe — a gate that ignores name collisions protects nobody.
+    const sameName = open
+        .filter((d) => normalizeName(d.name) === nameKey)
+        .map((d) => match(d.id, d.name, "name", `open deal with the same name on ${d.accountId ? `account ${d.accountId}` : "no account"}`));
+    if (sameName.length > 0) {
         return {
             ...base,
-            verdict: "exists",
-            matches,
-            reason: `${matches.length} open deal(s) already match "${c.name}" on ${c.accountId ? `account ${c.accountId}` : "unlinked"} — creating another would double-count pipeline. Update the existing deal.`,
+            verdict: "ambiguous",
+            matches: sameName,
+            reason: `${sameName.length} open deal(s) named "${c.name}" exist (no --account-id supplied to scope the check). Confirm before creating — supply --account-id to resolve definitively.`,
         };
     }
-    const closedSameName = snapshot.deals.filter((d) => (d.isClosed === true || d.isWon === true) && normalizeName(d.name) === normalizeName(c.name));
-    return {
-        ...base,
-        verdict: "safe_to_create",
-        matches: [],
-        reason: closedSameName.length > 0
-            ? `No open deal matches; ${closedSameName.length} closed deal(s) share the name (a re-open/renewal may be intended). Safe to create.`
-            : `No open deal matches "${c.name}". Safe to create.`,
-    };
+    return { ...base, verdict: "safe_to_create", matches: [], reason: `No open deal named "${c.name}" anywhere. Safe to create.` };
 }
 function contactName(row) {
     return [row.firstName, row.lastName].filter(Boolean).join(" ") || "(unnamed)";

package/dist/types.d.ts

@@ -9,7 +9,7 @@ export type CrmProvider = "salesforce" | "hubspot" | "mock" | "unknown" | (strin
 export type RiskLevel = "low" | "medium" | "high";
 export type ApprovalStatus = "draft" | "needs_approval" | "approved" | "rejected" | "applied";
 export type GtmObjectType = "account" | "contact" | "deal" | "user" | "activity";
-export type GtmEvidenceSourceSystem = "salesforce" | "hubspot" | "gong" | "chorus" | "fathom" | "manual" | "csv" | "mock" | "unknown";
+export type GtmEvidenceSourceSystem = "salesforce" | "hubspot" | "gong" | "chorus" | "fathom" | "manual" | "csv" | "mock" | "web" | "unknown";
 export type PatchOperationType = "set_field" | "clear_field" | "link_record" | "archive_record" | "create_task" | "merge_records";
 export type AuditFindingSeverity = "info" | "warning" | "critical";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "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",