fullstackgtm 0.21.1 → 0.22.0

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { auditSnapshot, defaultPolicy } from "./audit.ts";
-export { buildBulkUpdatePlan, parseWhere, type BulkUpdateOptions } from "./bulkUpdate.ts";
+export { buildBulkUpdatePlan, isFilterableField, parseWhere, type BulkUpdateOptions } from "./bulkUpdate.ts";
+export { buildDedupePlan, dedupeKey, type DedupeOptions } from "./dedupe.ts";
+export { buildReassignPlans, type ReassignObjectType, type ReassignOptions } from "./reassign.ts";
 export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, type FullstackgtmConfig, type LoadedConfig, } from "./config.ts";
 export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
 export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";

package/dist/index.js

@@ -1,5 +1,7 @@
 export { auditSnapshot, defaultPolicy } from "./audit.js";
-export { buildBulkUpdatePlan, parseWhere } from "./bulkUpdate.js";
+export { buildBulkUpdatePlan, isFilterableField, parseWhere } from "./bulkUpdate.js";
+export { buildDedupePlan, dedupeKey } from "./dedupe.js";
+export { buildReassignPlans } from "./reassign.js";
 export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, } from "./config.js";
 export { applyPatchPlan } from "./connector.js";
 export { createHubspotConnector } from "./connectors/hubspot.js";

package/dist/marketReport.js

@@ -149,19 +149,26 @@ function svgScatter(points, ax, ay, anchor, colorByVendor, numberByVendor) {
     const sx = (x) => PAD_X + ((x - xLo) / (xHi - xLo)) * (W - 2 * PAD_X);
     const sy = (y) => H - PAD_BOTTOM - ((y - yLo) / (yHi - yLo)) * (H - PAD_TOP - PAD_BOTTOM);
     const e = escapeHtml;
-    // Big bubbles first so small ones stay clickable/visible on top.
+    // Big bubbles first so small ones stay clickable/visible on top; hover
+    // raises a bubble to the front (JS re-appends its <g>), so even a bubble
+    // born fully underneath a bigger one is one mouse-over from visible.
     const ordered = [...points].sort((a, b) => b.size - a.size);
     const dots = ordered
         .map((p) => {
-        const r = 7 + 24 * Math.sqrt(p.size);
+        const r = p.noScale ? 7 : 7 + 24 * Math.sqrt(p.size);
         const color = colorByVendor.get(p.vendorId) ?? "#717171";
-        const ring = p.vendorId === anchor ? ` stroke="#1c1c1c" stroke-width="2.5"` : ` stroke="#ffffff" stroke-width="1.5"`;
         const number = numberByVendor.get(p.vendorId) ?? 0;
+        const cx = sx(p.x).toFixed(1);
+        const cy = sy(p.y);
+        const ring = p.vendorId === anchor ? ` stroke="#1c1c1c" stroke-width="2.5"` : ` stroke="#ffffff" stroke-width="1.5"`;
+        // No measurable scale: minimal dashed outline — visibly "no data", never a guess.
+        const fill = p.noScale ? ` fill="${color}" fill-opacity="0.2" stroke="${color}" stroke-width="1.5" stroke-dasharray="3 2"` : ` fill="${color}" fill-opacity="0.78"${ring}`;
+        // Numbers go inside when they fit, above the bubble when they don't.
         const fs = Math.max(10, Math.min(14, r * 0.9));
-        return (`<circle cx="${sx(p.x).toFixed(1)}" cy="${sy(p.y).toFixed(1)}" r="${r.toFixed(1)}" fill="${color}" fill-opacity="0.88"${ring}>` +
-            `<title>${e(p.name)}</title></circle>` +
-            `<text x="${sx(p.x).toFixed(1)}" y="${(sy(p.y) + fs * 0.36).toFixed(1)}" text-anchor="middle" ` +
-            `font-size="${fs.toFixed(1)}" font-weight="700" fill="${numeralColor(color)}" style="pointer-events:none">${number}</text>`);
+        const numberSvg = r >= 10 && !p.noScale
+            ? `<text x="${cx}" y="${(cy + fs * 0.36).toFixed(1)}" text-anchor="middle" font-size="${fs.toFixed(1)}" font-weight="700" fill="${numeralColor(color)}" style="pointer-events:none">${number}</text>`
+            : `<text x="${cx}" y="${(cy - r - 3).toFixed(1)}" text-anchor="middle" font-size="10" font-weight="700" fill="${color}" style="pointer-events:none">${number}</text>`;
+        return `<g class="bubble${p.noScale ? " no-scale" : ""}" data-v="${e(p.vendorId)}"><circle cx="${cx}" cy="${cy.toFixed(1)}" r="${r.toFixed(1)}"${fill}/>${numberSvg}</g>`;
     })
         .join("");
     const midX = ax.signed ? `<line class="grid" x1="${sx(0).toFixed(0)}" y1="${PAD_TOP}" x2="${sx(0).toFixed(0)}" y2="${H - PAD_BOTTOM}"/>` : "";
@@ -199,17 +206,27 @@ function axisSectionsHtml(config, set) {
     // when every placeable vendor has one; LOUD count otherwise — never mix
     // the two semantics on one chart.
     const scale = computeScaleIndex(config);
+    const scaleByVendor = new Map(scale.vendors.map((vendor) => [vendor.vendorId, vendor]));
     const scaleIndex = new Map(scale.vendors.map((vendor) => [vendor.vendorId, vendor.index]));
-    const useScale = report.vendors.length > 0 && report.vendors.every((vendorId) => scaleIndex.get(vendorId) !== null && scaleIndex.get(vendorId) !== undefined);
+    const estimated = report.vendors.filter((vendorId) => typeof scaleIndex.get(vendorId) === "number");
+    // Scale mode needs a real majority of vendors estimated; the stragglers
+    // (idea-stage anchors, signal-less vendors) render as minimal dashed
+    // bubbles — visibly "no measurable scale", never silently re-sized.
+    const useScale = estimated.length >= 2 && estimated.length * 2 >= report.vendors.length;
     const loudCounts = new Map(report.vendors.map((vendorId) => [vendorId, messageBreadth(vendorId, set.observations).loudCount]));
-    const maxLoud = Math.max(1, ...loudCounts.values());
     // Bubble areas stay proportional to the metric; dividing by the max just
     // spends the full visual range without distorting any ratio.
     const maxShare = Math.max(1e-9, ...report.vendors.map((vendorId) => scaleIndex.get(vendorId) ?? 0));
-    const sizeOf = (vendorId) => useScale ? scaleIndex.get(vendorId) / maxShare : (loudCounts.get(vendorId) ?? 0) / maxLoud;
+    const sizeOf = (vendorId) => {
+        if (!useScale)
+            return 0.14; // uniform: size carries NO meaning without scale signals
+        const share = scaleIndex.get(vendorId);
+        return typeof share === "number" ? share / maxShare : 0;
+    };
+    const noScaleFor = (vendorId) => useScale && typeof scaleIndex.get(vendorId) !== "number";
     const sizeCaption = useScale
-        ? `Dot area &#8733; estimated revenue share of this vendor set (signals: ${e(scale.metricsUsed.join(", "))}; calibrated within-set, ACV-band stratified, citable but NOT audited — see \`market scale\` for estimates and spreads)`
-        : "Dot area &#8733; LOUD count";
+        ? `Dot area &#8733; estimated revenue share of this vendor set (signals: ${e(scale.metricsUsed.join(", "))}; calibrated within-set, ACV-band stratified, citable but NOT audited — see \`market scale\` for estimates and spreads). Dashed outline = no measurable scale signals.`
+        : "Dot size carries no meaning on this map (no scaleSignals in the config); the legend lists LOUD counts";
     const breadthAxis = {
         id: "breadth",
         label: "Message breadth",
@@ -247,6 +264,7 @@ function axisSectionsHtml(config, set) {
             x: xs.get(vendorId),
             y: ys.get(vendorId),
             size: sizeOf(vendorId),
+            noScale: noScaleFor(vendorId),
         }));
     };
     const [px, py] = config.primaryAxes ?? [axes[0].id, axes[1]?.id ?? "breadth"];
@@ -265,13 +283,35 @@ function axisSectionsHtml(config, set) {
         const number = numberByVendor.get(point.vendorId);
         const color = colorByVendor.get(point.vendorId);
         const isAnchor = point.vendorId === config.anchorVendor;
+        const share = scaleIndex.get(point.vendorId);
         const measure = useScale
-            ? `${((scaleIndex.get(point.vendorId) ?? 0) * 100).toFixed(1)}%`
+            ? typeof share === "number"
+                ? `${(share * 100).toFixed(1)}%`
+                : "—"
             : `${loudCounts.get(point.vendorId) ?? 0} loud`;
-        return `<tr${isAnchor ? ' class="anchor-row"' : ""}><td><span class="swatch" style="background:${color};color:${numeralColor(color)}">${number}</span></td><td>${e(point.name)}${isAnchor ? " ·&nbsp;anchor" : ""}</td><td class="num">${measure}</td></tr>`;
+        return `<tr data-v="${e(point.vendorId)}"${isAnchor ? ' class="anchor-row"' : ""}><td><span class="swatch" style="background:${color};color:${numeralColor(color)}">${number}</span></td><td>${e(point.name)}${isAnchor ? " ·&nbsp;anchor" : ""}</td><td class="num">${measure}</td></tr>`;
     })
         .join("");
     const legendMeasureHead = useScale ? "est. share" : "loud";
+    const money = (value) => value >= 1e9 ? `$${(value / 1e9).toFixed(1)}B` : value >= 1e6 ? `$${(value / 1e6).toFixed(1)}M` : `$${Math.round(value / 1e3)}K`;
+    const tipData = {};
+    for (const point of points) {
+        const vendorScale = scaleByVendor.get(point.vendorId);
+        const lines = [
+            `${axInfo.label}: ${point.x.toFixed(2)}`,
+            `${ayInfo.label}: ${point.y.toFixed(2)}`,
+            `LOUD claims: ${loudCounts.get(point.vendorId) ?? 0}`,
+        ];
+        if (useScale) {
+            if (vendorScale?.estimatedRevenue != null) {
+                lines.push(`est. revenue: ~${money(vendorScale.estimatedRevenue)} (${((scaleIndex.get(point.vendorId) ?? 0) * 100).toFixed(1)}% of set${vendorScale.uncertainty && vendorScale.uncertainty > 1 ? `, ×${vendorScale.uncertainty.toFixed(1)} signal spread` : ""})`);
+            }
+            else {
+                lines.push("est. revenue: no measurable scale signals");
+            }
+        }
+        tipData[point.vendorId] = { name: point.name, n: numberByVendor.get(point.vendorId) ?? 0, lines };
+    }
     const strategicMap = `<section>
   <h2>Strategic map: ${e(axInfo.label)} &#215; ${e(ayInfo.label)}</h2>
   <figure class="map">
@@ -279,6 +319,47 @@ function axisSectionsHtml(config, set) {
       ${svgScatter(points, axInfo, ayInfo, config.anchorVendor, colorByVendor, numberByVendor)}
       <table class="legend"><thead><tr><th></th><th>vendor</th><th class="num">${legendMeasureHead}</th></tr></thead><tbody>${legendRows}</tbody></table>
     </div>
+    <div class="map-tip" id="map-tip" hidden></div>
+    <script type="application/json" id="map-data">${JSON.stringify(tipData)}</script>
+    <script>
+    (function () {
+      var data = JSON.parse(document.getElementById("map-data").textContent);
+      var tip = document.getElementById("map-tip");
+      var fig = tip.closest("figure");
+      var bubbles = fig.querySelectorAll("g.bubble");
+      var rows = fig.querySelectorAll("table.legend tbody tr");
+      function show(v, evt) {
+        var d = data[v];
+        if (!d) return;
+        tip.innerHTML = "<b>" + d.n + " · " + d.name + "</b>" + d.lines.map(function (l) { return "<div>" + l + "</div>"; }).join("");
+        tip.hidden = false;
+        var box = fig.getBoundingClientRect();
+        tip.style.left = Math.min(evt.clientX - box.left + 14, box.width - tip.offsetWidth - 8) + "px";
+        tip.style.top = (evt.clientY - box.top + 14) + "px";
+      }
+      function focusOn(v) {
+        bubbles.forEach(function (b) {
+          b.classList.toggle("dim", b.getAttribute("data-v") !== v);
+          if (b.getAttribute("data-v") === v) b.parentNode.appendChild(b); // raise hidden bubbles
+        });
+        rows.forEach(function (r) { r.classList.toggle("hl", r.getAttribute("data-v") === v); });
+      }
+      function clear() {
+        tip.hidden = true;
+        bubbles.forEach(function (b) { b.classList.remove("dim"); });
+        rows.forEach(function (r) { r.classList.remove("hl"); });
+      }
+      bubbles.forEach(function (b) {
+        b.addEventListener("mousemove", function (evt) { show(b.getAttribute("data-v"), evt); });
+        b.addEventListener("mouseenter", function () { focusOn(b.getAttribute("data-v")); });
+        b.addEventListener("mouseleave", clear);
+      });
+      rows.forEach(function (r) {
+        r.addEventListener("mouseenter", function () { focusOn(r.getAttribute("data-v")); });
+        r.addEventListener("mouseleave", clear);
+      });
+    })();
+    </script>
   <figcaption>Positions computed from run ${e(set.runLabel)} observations: each axis is a per-claim scoring rubric
   in the market config; a vendor sits at the intensity-weighted mean (loud=1, quiet=&#189;) of the claims it
   voices. ${sizeCaption}. Axis status — ${e(axInfo.label)}: ${e(statusOf(px))}; ${e(ayInfo.label)}: ${e(statusOf(py))}.</figcaption>
@@ -301,8 +382,9 @@ export function marketMapToHtml(config, set) {
     const anchor = config.anchorVendor;
     const e = escapeHtml;
     const axisHtml = axisSectionsHtml(config, set);
-    const matrixRows = model.orderedClaimIds
-        .map((claimId) => {
+    const vendorNamesById = new Map(config.vendors.map((vendor) => [vendor.id, vendor.name]));
+    const frontByClaim = new Map(model.fronts.map((front) => [front.claimId, front]));
+    const matrixRow = (claimId) => {
         const claim = claimsById.get(claimId);
         if (!claim)
             return "";
@@ -317,27 +399,87 @@ export function marketMapToHtml(config, set) {
         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) => {
+    };
+    // 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.
+    const GROUPS = [
+        { states: ["open", "vacant"], title: "Open ground", blurb: "no vendor is loud here" },
+        { states: ["contested"], title: "Contested fronts", blurb: "2–3 vendors loud" },
+        { states: ["owned"], title: "Owned fronts", blurb: "exactly one vendor loud" },
+        { states: ["saturated"], title: "Saturated fronts", blurb: "4+ vendors loud" },
+    ];
+    const groupedMatrix = GROUPS.map((group) => {
+        const claimIds = model.orderedClaimIds.filter((claimId) => group.states.includes(stateByClaim.get(claimId) ?? "vacant"));
+        if (claimIds.length === 0)
+            return "";
+        const anchorLoud = anchor
+            ? claimIds.filter((claimId) => model.cell(anchor, claimId)?.intensity === "loud").length
+            : 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>
+    </details>`;
+    }).join("");
+    // The closing argument: walk from open ground to a reasoned target list.
+    const openFronts = model.orderedClaimIds.filter((claimId) => {
         const state = stateByClaim.get(claimId);
         return state === "open" || state === "vacant";
-    })
+    });
+    const targetItems = openFronts
         .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>`;
+        const front = frontByClaim.get(claimId);
+        if (!claim || !front)
+            return "";
+        const quietNames = front.quietVendorIds.map((id) => vendorNamesById.get(id) ?? id);
+        const anchorIntensity = anchor ? model.cell(anchor, claimId)?.intensity ?? "unobservable" : null;
+        const nearest = quietNames.length > 0
+            ? `Closest contenders (quiet): ${quietNames.join(", ")}.`
+            : "Nobody even ships it quietly — vacant ground.";
+        const move = anchorIntensity === "quiet"
+            ? `${e(vendorNamesById.get(anchor) ?? "The anchor")} already ships this quietly — a promote-to-loud candidate.`
+            : anchorIntensity === "absent"
+                ? "Unclaimed by the anchor: a first-mover messaging opportunity if the capability is real or buildable."
+                : "";
+        return `<li><b>${e(claim.capability.split(":")[0])}</b> <span class="sum-soft">(${e(claim.icp)} · ${e(claim.pricingStructure)})</span><br>
+        No vendor is loud on this claim. ${e(nearest)} ${move}</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>`);
-    }))
+    const heldFronts = anchor
+        ? model.fronts.filter((front) => front.state === "owned" && front.loudVendorIds[0] === anchor)
+        : [];
+    const heldLine = heldFronts.length > 0
+        ? `<p><b>Held ground:</b> ${e(vendorNamesById.get(anchor) ?? "the anchor")} is the sole loud vendor on ${heldFronts
+            .map((front) => `<i>${e(claimsById.get(front.claimId)?.capability.split(":")[0] ?? front.claimId)}</i>`)
+            .join(", ")} — positions to defend, not abandon.</p>`
+        : "";
+    const crowdLine = counts.saturated > 0
+        ? `<p><b>Crowded ground:</b> ${counts.saturated} claim${counts.saturated === 1 ? " is" : "s are"} saturated (4+ vendors loud) — message budget spent there buys the least differentiation.</p>`
+        : "";
+    const takeaway = `<section>
+  <h2>Where to attack</h2>
+  <p class="lede">${openFronts.length === 0 ? "No open fronts this run — every claim has at least one loud vendor. Watch the drift between runs for windows opening." : `${openFronts.length} claim${openFronts.length === 1 ? "" : "s"} in this category ${openFronts.length === 1 ? "is" : "are"} open: buyers can be reached there without out-shouting anyone.`}</p>
+  <ul class="targets">${targetItems}</ul>
+  ${heldLine}
+  ${crowdLine}
+  <p class="sum-soft">These are messaging fronts, not verdicts — join the map to CRM ground truth (\`market overlay\`) for evidence-backed OCCUPY / PROMOTE / URGENT / RETREAT directives with win-rate stats.</p>
+</section>`;
+    // Evidence grouped by vendor, collapsed: receipts on demand, not a scroll wall.
+    const appendixGroups = config.vendors
+        .map((vendor) => {
+        const items = model.orderedClaimIds.flatMap((claimId) => {
+            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(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>`);
+        });
+        if (items.length === 0)
+            return "";
+        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>`)
@@ -357,14 +499,16 @@ h1 { font-size:27px; font-weight:600; line-height:1.2; }
 .meta { font-size:11px; color:var(--soft); display:flex; gap:18px; flex-wrap:wrap; margin-top:8px; }
 section { margin-top:44px; }
 h2 { font-size:17px; font-weight:600; border-bottom:1px solid var(--line); padding-bottom:7px; margin-bottom:4px; }
-.fronts { display:grid; grid-template-columns:repeat(4,1fr); gap:1px; background:var(--line); border:1px solid var(--line); margin-top:16px; }
-.fcard { background:#fff; padding:14px 16px 12px; }
-.fcard b { display:block; font-size:30px; font-weight:600; line-height:1.1; }
-.fcard span { font-size:11px; color:var(--soft); }
-.fcard.open b { color:var(--accent); }
-.openlist { margin-top:14px; font-size:14.5px; line-height:1.55; }
-.openlist li { margin:3px 0 3px 20px; }
-.openlist .why { color:var(--soft); font-size:13px; }
+details.claim-group, details.ev-group { border:1px solid var(--line); border-radius:3px; margin-top:10px; }
+details.claim-group summary, details.ev-group summary { cursor:pointer; padding:10px 14px; font-size:14px; list-style-position:inside; }
+details.claim-group summary:hover, details.ev-group summary:hover { background:var(--faint); }
+details.claim-group[open] summary, details.ev-group[open] summary { border-bottom:1px solid var(--line); }
+details.claim-group table { margin:4px 12px 12px; width:calc(100% - 24px); }
+details.ev-group .ev { margin:0 14px; }
+.sum-soft { color:var(--soft); font-size:12px; }
+.lede { font-size:16px; margin-top:12px; }
+.targets { margin-top:12px; font-size:14.5px; line-height:1.6; }
+.targets li { margin:10px 0 10px 20px; }
 .key { display:flex; gap:20px; flex-wrap:wrap; margin:14px 0 8px; font-size:10.5px; color:var(--soft); }
 .lg { display:inline-flex; align-items:center; gap:6px; }
 table { border-collapse:collapse; width:100%; margin-top:6px; }
@@ -390,7 +534,15 @@ tr.front-open th .claim-cap { color:var(--accent); font-weight:600; }
 .ev-head { font-size:10.5px; color:var(--soft); font-weight:600; }
 .ev blockquote { margin:5px 0; font-size:13.5px; line-height:1.5; }
 .ev-src { font-size:10px; color:var(--soft); word-break:break-all; }
-figure.map { margin-top:16px; border:1px solid var(--line); }
+figure.map { margin-top:16px; border:1px solid var(--line); position:relative; }
+g.bubble { cursor:pointer; }
+g.bubble.dim { opacity:0.25; transition:opacity .12s; }
+table.legend tbody tr { cursor:default; }
+table.legend tbody tr.hl td { background:var(--faint); }
+.map-tip { position:absolute; z-index:5; background:#1c1c1c; color:#fff; font-size:11.5px; line-height:1.45;
+  padding:8px 10px; border-radius:3px; pointer-events:none; max-width:260px;
+  font-family:ui-monospace,"SF Mono",Menlo,Consolas,monospace; }
+.map-tip b { display:block; margin-bottom:3px; }
 .map-row { display:flex; gap:8px; align-items:flex-start; padding:10px 12px 0; }
 .map-row svg { flex:1 1 62%; min-width:0; }
 .plot { fill:var(--faint); stroke:var(--line); }
@@ -406,7 +558,7 @@ table.legend tr.anchor-row td { font-weight:700; }
 figcaption { font-size:11.5px; color:var(--soft); padding:10px 14px 12px; border-top:1px solid var(--line); line-height:1.5; }
 footer { margin-top:60px; border-top:1px solid var(--ink); padding-top:12px; font-size:11px; color:var(--soft);
   display:flex; justify-content:space-between; gap:20px; flex-wrap:wrap; }
-@media print { body { max-width:none; padding:0 8mm; } section { break-inside:avoid-page; } tr { break-inside:avoid; } .map-row { display:block; } }
+@media print { body { max-width:none; padding:0 8mm; } section { break-inside:avoid-page; } tr { break-inside:avoid; } .map-row { display:block; } .map-tip { display:none; } }
 @media (max-width:760px) { .map-row { display:block; } }
 </style></head><body>
 <header>
@@ -417,34 +569,24 @@ footer { margin-top:60px; border-top:1px solid var(--ink); padding-top:12px; fon
     <span>extractor: ${e(set.extractor)}</span>
   </div>
 </header>
+${axisHtml.strategicMap}
 <section>
-  <h2>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>Claim × vendor intensity matrix</h2>
+  <h2>Claims, front by front</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>
     <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>
+  ${groupedMatrix}
 </section>
-${axisHtml.strategicMap}
+${takeaway}
 <section>
   <h2>Evidence appendix</h2>
-  ${appendix}
+  <p class="sum-soft">Every loud/quiet reading is grounded in a verbatim span from a stored page capture; expand a vendor for its receipts.</p>
+  ${appendixGroups}
 </section>
+<script>window.addEventListener("beforeprint",function(){document.querySelectorAll("details").forEach(function(d){d.open=true;});});</script>
 <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>

package/dist/reassign.d.ts

@@ -0,0 +1,19 @@
+import type { CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+export type ReassignObjectType = "account" | "contact" | "deal";
+export type ReassignOptions = {
+    /** the owner whose records are being handed off */
+    fromOwnerId: string;
+    /** the receiving owner — must be a known user in the snapshot */
+    toOwnerId: string;
+    /** which object types to compile plans for (default all three) */
+    objects?: ReassignObjectType[];
+    /** extra --where scoping, AND-ed into every plan (account fields lifted) */
+    where?: string[];
+    /** exclude records tied to an open deal in this stage (see module doc) */
+    exceptDealStage?: string;
+    /** also reassign closed deals (default false: history keeps its owner) */
+    includeClosedDeals?: boolean;
+    reason?: string;
+    maxOperations?: number;
+};
+export declare function buildReassignPlans(snapshot: CanonicalGtmSnapshot, options: ReassignOptions): PatchPlan[];

package/dist/reassign.js

@@ -0,0 +1,87 @@
+/**
+ * The ownership-handoff playbook: `reassign` compiles one bulk-update-style
+ * dry-run plan PER object type (accounts, contacts, deals by default) that
+ * moves every record owned by --from to --to. It NEVER writes — each plan
+ * flows through the same plans-approve → apply gate, and because every plan
+ * carries its full filter, eligibility (extra --where scoping AND the
+ * --except-deal-stage exclusion) is re-verified per record against a FRESH
+ * snapshot at apply time, with mid-apply rechecks. A record that drifts into
+ * the exception set mid-run surfaces as a conflict, not a bad write.
+ *
+ * --except-deal-stage <stage> excludes in-flight business end to end:
+ *   - deal plans drop deals in that stage (stage!=<stage>), and
+ *   - ALL plans drop records whose account has an OPEN deal in that stage
+ *     (accounts: openDealStages!~<stage>; deals/contacts:
+ *     account.openDealStages!~<stage>).
+ *
+ * Deal plans cover OPEN deals only unless includeClosedDeals is set: closed
+ * deals keep their historical owner in a handoff.
+ *
+ * Extra --where clauses are account-scoped where needed: a clause on a field
+ * that only exists on accounts (e.g. domain~.de) is lifted to the relational
+ * pseudo-field (account.domain~.de) for contact and deal plans, so one
+ * invocation scopes all three object types consistently.
+ */
+import { buildBulkUpdatePlan, isFilterableField, parseWhere } from "./bulkUpdate.js";
+const ALL_OBJECTS = ["account", "contact", "deal"];
+/**
+ * Scope an extra --where clause to one object type: pass through when the
+ * field is valid there, lift account-only fields to account.<field> for
+ * contacts and deals. Unknown fields fall through to buildBulkUpdatePlan's
+ * strict validation, which throws with the valid-field list.
+ */
+function scopeWhere(objectType, raw) {
+    const clause = parseWhere(raw);
+    if (isFilterableField(objectType, clause.field))
+        return raw;
+    if (objectType !== "account" && isFilterableField(objectType, `account.${clause.field}`)) {
+        return `account.${raw}`;
+    }
+    return raw;
+}
+export function buildReassignPlans(snapshot, options) {
+    if (!options.fromOwnerId || !options.toOwnerId) {
+        throw new Error("reassign requires both --from <ownerId> and --to <ownerId>.");
+    }
+    if (options.fromOwnerId === options.toOwnerId) {
+        throw new Error("reassign --from and --to are the same owner — nothing to hand off.");
+    }
+    // The receiving owner must exist: a typo'd --to would otherwise write an
+    // invalid owner onto every matched record.
+    if (!snapshot.users.some((user) => user.id === options.toOwnerId)) {
+        throw new Error(`reassign --to ${options.toOwnerId} is not a known user in the snapshot. Known users: ${snapshot.users
+            .map((user) => `${user.id} (${user.name})`)
+            .join(", ") || "none"}.`);
+    }
+    const objects = options.objects ?? ALL_OBJECTS;
+    for (const objectType of objects) {
+        if (!ALL_OBJECTS.includes(objectType)) {
+            throw new Error(`reassign --objects supports account, contact, deal — got "${objectType}".`);
+        }
+    }
+    return objects.map((objectType) => {
+        const where = [`ownerId=${options.fromOwnerId}`];
+        if (objectType === "deal" && !options.includeClosedDeals) {
+            where.push("isClosed=false"); // closed deals keep their historical owner
+        }
+        for (const extra of options.where ?? []) {
+            where.push(scopeWhere(objectType, extra));
+        }
+        if (options.exceptDealStage) {
+            const stage = options.exceptDealStage;
+            if (objectType === "deal")
+                where.push(`stage!=${stage}`);
+            where.push(objectType === "account"
+                ? `openDealStages!~${stage}`
+                : `account.openDealStages!~${stage}`);
+        }
+        return buildBulkUpdatePlan(snapshot, {
+            objectType,
+            where,
+            set: { ownerId: options.toOwnerId },
+            reason: options.reason ??
+                `reassign: hand off ${objectType}s from owner ${options.fromOwnerId} to ${options.toOwnerId}`,
+            maxOperations: options.maxOperations,
+        });
+    });
+}

package/dist/suggest.js

@@ -64,11 +64,39 @@ function suggestDealAccount(operation, dealsById, accountsByNorm, accountsById,
     if (!deal) {
         return { ...base, suggestedValue: null, confidence: "none", reason: "Deal not found in the snapshot." };
     }
-    // Convention: "Contact Name - Company Name". Both signals below are
-    // independent; agreement upgrades confidence, conflict downgrades it.
-    const separatorIndex = deal.name.indexOf(" - ");
-    const left = separatorIndex >= 0 ? deal.name.slice(0, separatorIndex) : deal.name;
-    const right = separatorIndex >= 0 ? deal.name.slice(separatorIndex + 3).trim() : "";
+    // Convention 1: "Contact Name - Company Name" (hyphen, en or em dash).
+    // Both signals below are independent; agreement upgrades confidence,
+    // conflict downgrades it.
+    const separator = [" - ", " – ", " — "]
+        .map((s) => ({ s, index: deal.name.indexOf(s) }))
+        .filter(({ index }) => index >= 0)
+        .sort((a, b) => a.index - b.index)[0];
+    const left = separator ? deal.name.slice(0, separator.index).trim() : deal.name;
+    const right = separator ? deal.name.slice(separator.index + separator.s.length).trim() : "";
+    // Convention 2: "Company - Deal descriptor" (e.g. "Globex – Expansion",
+    // "Hooli – New Business"). When the right side is purely deal-descriptor
+    // words, the company is on the LEFT. Only an exact account-name match
+    // counts as high; an unknown left side proposes a create — the engine
+    // never guesses at an existing record.
+    if (left && right && isDealDescriptor(right)) {
+        const leftMatch = accountsByNorm.get(normalize(left));
+        if (leftMatch) {
+            return {
+                ...base,
+                suggestedValue: leftMatch.id,
+                confidence: "high",
+                reason: `Deal name leads with the exact account name "${leftMatch.name}" ("${right}" is a deal descriptor, not a company).`,
+            };
+        }
+        if (!contactsByName.get(normalize(left))) {
+            return {
+                ...base,
+                suggestedValue: `create:${left}`,
+                confidence: "create",
+                reason: `No account named "${left}" exists ("${right}" is a deal descriptor) — approving creates the company, then links.`,
+            };
+        }
+    }
     // Signal 1: company-name match against account names.
     let nameMatch = null;
     let nameMatchKind = "";
@@ -135,6 +163,23 @@ function suggestDealAccount(operation, dealsById, accountsByNorm, accountsById,
             reason: `No account named "${right}" exists and contact "${left}" has none — approving creates the company, then links.`,
         };
     }
+    // Convention 3: "<Company> <descriptor…>" without a separator (e.g.
+    // "INITECH renewal"): strip trailing descriptor words and accept only an
+    // exact account-name match on what remains.
+    if (!separator) {
+        const words = normalize(deal.name).split(" ").filter(Boolean);
+        while (words.length > 1 && DEAL_DESCRIPTOR_WORDS.has(words[words.length - 1]))
+            words.pop();
+        const strippedMatch = words.length > 0 ? accountsByNorm.get(words.join(" ")) : undefined;
+        if (strippedMatch) {
+            return {
+                ...base,
+                suggestedValue: strippedMatch.id,
+                confidence: "high",
+                reason: `Deal name leads with the exact account name "${strippedMatch.name}" (trailing words are deal descriptors).`,
+            };
+        }
+    }
     return {
         ...base,
         suggestedValue: null,
@@ -144,6 +189,23 @@ function suggestDealAccount(operation, dealsById, accountsByNorm, accountsById,
             : `Deal name "${deal.name}" has no "Contact - Company" pattern to derive a company from. Supply --value ${operation.id}=<accountId> or create:<Company Name>.`,
     };
 }
+/**
+ * Words that describe the deal rather than name a company. Used to recognize
+ * the "Company - Deal descriptor" naming convention: a segment counts as a
+ * descriptor only when EVERY word is in this list, so any real company name
+ * ("Brand New Startup") falls through to the contact/company conventions.
+ */
+const DEAL_DESCRIPTOR_WORDS = new Set([
+    "renewal", "expansion", "pilot", "annual", "monthly", "platform", "new", "business",
+    "add", "on", "addon", "upsell", "upgrade", "trial", "poc", "proof", "concept",
+    "subscription", "license", "licence", "contract", "opportunity", "deal", "engagement",
+    "implementation", "onboarding", "services", "inbound", "outbound",
+    "q1", "q2", "q3", "q4",
+]);
+function isDealDescriptor(segment) {
+    const words = normalize(segment).split(" ").filter(Boolean);
+    return words.length > 0 && words.every((word) => DEAL_DESCRIPTOR_WORDS.has(word));
+}
 /**
  * Survivor selection for merge_records. Ranking is deterministic and
  * evidence-based: most complete record first (count of populated canonical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.21.1",
+  "version": "0.22.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",