fullstackgtm 0.21.1 → 0.22.0

package/src/marketReport.ts

@@ -107,7 +107,7 @@ export function marketMapToMarkdown(config: MarketConfig, set: ObservationSet):
 }
 
 /** size is normalized [0,1]; rendered area-proportionally (radius ∝ √size). */
-type ScatterPoint = { vendorId: string; name: string; x: number; y: number; size: number };
+type ScatterPoint = { vendorId: string; name: string; x: number; y: number; size: number; noScale?: boolean };
 type ScatterAxis = { label: string; negativePole: string; positivePole: string; signed: boolean };
 
 /**
@@ -185,21 +185,27 @@ function svgScatter(
   const sy = (y: number) => 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("");
 
@@ -244,18 +250,26 @@ function axisSectionsHtml(
   // 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: string): number =>
-    useScale ? (scaleIndex.get(vendorId) as number) / maxShare : (loudCounts.get(vendorId) ?? 0) / maxLoud;
+  const sizeOf = (vendorId: string): number => {
+    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: string): boolean => 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: ScatterAxis & { id: string } = {
     id: "breadth",
@@ -298,6 +312,7 @@ function axisSectionsHtml(
         x: xs.get(vendorId) as number,
         y: ys.get(vendorId) as number,
         size: sizeOf(vendorId),
+        noScale: noScaleFor(vendorId),
       }));
   };
 
@@ -318,14 +333,39 @@ function axisSectionsHtml(
       const number = numberByVendor.get(point.vendorId);
       const color = colorByVendor.get(point.vendorId) as string;
       const isAnchor = point.vendorId === config.anchorVendor;
+      const share = scaleIndex.get(point.vendorId);
       const measure = useScale
-        ? `${(((scaleIndex.get(point.vendorId) as number) ?? 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: number) =>
+    value >= 1e9 ? `$${(value / 1e9).toFixed(1)}B` : value >= 1e6 ? `$${(value / 1e6).toFixed(1)}M` : `$${Math.round(value / 1e3)}K`;
+  const tipData: Record<string, { name: string; n: number; lines: string[] }> = {};
+  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) as number) ?? 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">
@@ -333,6 +373,47 @@ function axisSectionsHtml(
       ${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>
@@ -357,50 +438,112 @@ export function marketMapToHtml(config: MarketConfig, set: ObservationSet): stri
   const e = escapeHtml;
   const axisHtml = axisSectionsHtml(config, set);
 
-  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 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: string): string => {
+    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>`
+    );
+  };
 
-  const openList = model.orderedClaimIds
-    .filter((claimId) => {
-      const state = stateByClaim.get(claimId);
-      return state === "open" || state === "vacant";
-    })
+  // 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: Array<{ states: FrontState[]; title: string; blurb: string }> = [
+    { 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 as string) ?? "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 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 as string) ?? "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>`;
 
-  const appendix = model.orderedClaimIds
-    .flatMap((claimId) =>
-      config.vendors.flatMap((vendor) => {
+  // 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(vendor.name)} · ${e(claimId)} · ${obs.intensity.toUpperCase()} (${obs.confidence})</span>` +
+            `<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
@@ -425,14 +568,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; }
@@ -458,7 +603,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); }
@@ -474,7 +627,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>
@@ -485,34 +638,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/src/reassign.ts

@@ -0,0 +1,117 @@
+/**
+ * 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.ts";
+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;
+};
+
+const ALL_OBJECTS: ReassignObjectType[] = ["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: ReassignObjectType, raw: string): string {
+  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: CanonicalGtmSnapshot,
+  options: ReassignOptions,
+): PatchPlan[] {
+  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/src/suggest.ts

@@ -114,11 +114,40 @@ function suggestDealAccount(
     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: { id: string; name: string } | null = null;
@@ -189,6 +218,22 @@ function suggestDealAccount(
       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,
@@ -199,6 +244,25 @@ function suggestDealAccount(
   };
 }
 
+/**
+ * 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: string): boolean {
+  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