fullstackgtm 0.21.2 → 0.22.0

package/src/marketReport.ts

@@ -438,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
@@ -506,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; }
@@ -574,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