fullstackgtm 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -5,6 +5,54 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 The path to 1.0 is planned in [docs/roadmap-to-1.0.md](./docs/roadmap-to-1.0.md).
 
+## [0.16.0] — 2026-06-11
+
+The market map: a live model of the competitive category a company sells
+into — claim taxonomy as reviewable config, append-only observations with
+verbatim-quote evidence, deterministic front states and drift.
+
+### Added
+
+- **`fullstackgtm market`** — `init` scaffolds a `market.config.json`
+  (vendor registry + claim taxonomy + the LOUD/QUIET/ABSENT surface rule);
+  `capture` fetches vendor pages into a content-addressed text cache (the
+  change detector, replay buffer, and evidence chain); `observe --from`
+  ingests intensity readings after validating full coverage and the
+  verbatim-evidence rule (a loud/quiet reading with no quote is rejected);
+  `fronts` computes deterministic front states (open / contested / owned /
+  saturated / vacant) and `--diff` reports drift between runs; `report`
+  renders the claim × vendor matrix as markdown or a self-contained
+  printable HTML field report with an evidence appendix.
+- **Division of labor matches call intelligence:** intensity readings are
+  proposals (provenance-marked extractor, always with quoted evidence);
+  everything downstream is deterministic over the stored observations —
+  same observations, same map. A failed capture reads as UNOBSERVABLE,
+  never as absence.
+- **Profile-scoped storage:** captures and observations live under
+  `~/.fullstackgtm/market/<category>` (or the active profile's home), so one
+  client org's category intel never bleeds into another's.
+- `ObservationStore` contract + file implementation (append-only, one JSON
+  document per run) — like the plan store, the file layout and the hosted
+  backend are two implementations of the same contract.
+- `"web"` joined `GtmEvidenceSourceSystem`: market observations carry
+  standard `GtmEvidence` with `metadata.url` + `metadata.captureHash`.
+
+## [0.15.1] — 2026-06-11
+
+Fixes from the 0.15.0 journey verification (4 agents, 26 checks).
+
+### Fixed
+
+- **Name-only deal resolution is gated**: `resolve deal --name X` without
+  `--account-id` returned safe_to_create even when open deals named X
+  existed — a gate that ignores name collisions protects nobody. It now
+  returns ambiguous with the colliding open deals and tells the caller to
+  supply `--account-id` for a definitive answer.
+- The closed-deals-share-name note is account-scoped (it previously counted
+  closed deals on *other* accounts).
+- The `hs_object_source_detail_2` stamp on CLI-created companies now
+  carries the operation id for precise attribution.
+
 ## [0.15.0] — 2026-06-11
 
 The Prevent layer: stop creating duplicates, and name the writer that does.

package/dist/cli.js

@@ -18,6 +18,8 @@ import { auditReportToHtml, auditReportToMarkdown } from "./report.js";
 import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall, suggestCallDeal } from "./calls.js";
+import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadMarketConfig, starterMarketConfig, validateObservationSet, } from "./market.js";
+import { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 import { DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
 import { resolveRecord } from "./resolve.js";
 import { suggestValues } from "./suggest.js";
@@ -55,6 +57,15 @@ Usage:
   fullstackgtm resolve <account|contact|deal> [--name N] [--domain D] [--email E] [--account-id A] [source options] [--json]
                                                the create gate: exit 0 = safe to create, exit 2 = match
                                                found (exists/ambiguous) — call before ANY record creation
+  fullstackgtm market init --category <name>   start a market map: vendors + claim taxonomy as reviewable config
+  fullstackgtm market capture [--config <path>] [--run <label>]
+  fullstackgtm market observe --from <observations.json>
+  fullstackgtm market fronts [--run <label>] [--diff <prior-run>] [--json]
+  fullstackgtm market report [--run <label>] [--format md|html] [--out <path>]
+                                               the live competitive map: capture vendor pages (content-addressed),
+                                               ingest intensity readings with verbatim-quote evidence, compute
+                                               deterministic front states (open/contested/owned/saturated) and
+                                               drift between runs, render the client-ready field report
   fullstackgtm suggest --plan-id <id> | --plan <path>  [source options] [--json] [--out <path>]
                                                derive values for requires_human_* placeholders
                                                from snapshot evidence, with confidence + reasons
@@ -715,6 +726,120 @@ function buildCallPlan(parsed, deal, proposed, current, extraNextSteps) {
         operations,
     };
 }
+/**
+ * The market map: claim taxonomy in a reviewable config file, page captures
+ * and append-only observations under the profile home, deterministic front
+ * states and reports computed from the store. Classification (LLM intensity
+ * readings) lands in a later change; until then `market observe --from`
+ * ingests proposal files produced by an agent or a human.
+ */
+async function marketCommand(args) {
+    const [subcommand, ...rest] = args;
+    const configPath = () => resolve(process.cwd(), option(rest, "--config") ?? "market.config.json");
+    if (!subcommand || subcommand === "--help") {
+        console.log(`Usage:
+market init --category <name> [--out <path>]   write a starter market.config.json
+market capture [--config <path>] [--run <label>]
+market observe --from <observations.json> [--config <path>]
+market fronts [--config <path>] [--run <label>] [--diff <prior-run>] [--json]
+market report [--config <path>] [--run <label>] [--format md|html] [--out <path>]
+
+The taxonomy (vendors + claims) is config you review and version; captures
+and observations live under ~/.fullstackgtm/market/<category> (profile-scoped,
+one client's category intel never bleeds into another's). Front states are
+recomputed deterministically on every invocation — never stored.`);
+        return;
+    }
+    if (subcommand === "init") {
+        const category = option(rest, "--category");
+        if (!category)
+            throw new Error("market init requires --category <name>");
+        const outPath = resolve(process.cwd(), option(rest, "--out") ?? "market.config.json");
+        if (existsSync(outPath))
+            throw new Error(`${outPath} already exists — refusing to overwrite`);
+        writeFileSync(outPath, `${JSON.stringify(starterMarketConfig(category), null, 2)}\n`);
+        console.log(`Wrote ${outPath}. Fill in vendors and claims, then: fullstackgtm market capture`);
+        return;
+    }
+    const config = loadMarketConfig(configPath());
+    const store = createFileObservationStore(config.category);
+    if (subcommand === "capture") {
+        const result = await captureMarket(config, { runLabel: option(rest, "--run") ?? "run-1" });
+        for (const entry of result.entries) {
+            const flag = entry.captureHash && entry.textChars > 500 ? "" : "  <-- thin/empty";
+            console.log(`${entry.vendorId.padEnd(16)} ${entry.kind.padEnd(8)} ${String(entry.httpStatus ?? "ERR").padEnd(4)} ${String(entry.textChars).padStart(7)} chars  ${entry.url}${flag}`);
+        }
+        console.log(`\nmanifest: ${result.manifestPath}`);
+        return;
+    }
+    if (subcommand === "observe") {
+        const fromPath = option(rest, "--from");
+        if (!fromPath)
+            throw new Error("market observe requires --from <observations.json>");
+        const set = JSON.parse(readFileSync(resolve(process.cwd(), fromPath), "utf8"));
+        const problems = validateObservationSet(config, set);
+        if (problems.length > 0) {
+            console.error(`Rejected: ${problems.length} problem(s)`);
+            for (const problem of problems.slice(0, 20))
+                console.error(`  - ${problem}`);
+            process.exitCode = 1;
+            return;
+        }
+        await store.append(set);
+        console.log(`Appended ${set.runLabel}: ${set.observations.length} observations (${set.extractor})`);
+        return;
+    }
+    const loadSet = async () => {
+        const runLabel = option(rest, "--run");
+        const set = runLabel ? await store.get(runLabel) : await store.latest();
+        if (!set) {
+            throw new Error(runLabel
+                ? `No observation run "${runLabel}" for ${config.category}`
+                : `No observations stored for ${config.category} — run market observe --from <file> first`);
+        }
+        return set;
+    };
+    if (subcommand === "fronts") {
+        const set = await loadSet();
+        const fronts = computeFrontStates(config, set);
+        const priorLabel = option(rest, "--diff");
+        const prior = priorLabel ? await store.get(priorLabel) : null;
+        if (priorLabel && !prior)
+            throw new Error(`No observation run "${priorLabel}" to diff against`);
+        const drift = prior ? diffFrontStates(computeFrontStates(config, prior), fronts) : null;
+        if (rest.includes("--json")) {
+            console.log(JSON.stringify({ runLabel: set.runLabel, fronts, drift }, null, 2));
+            return;
+        }
+        for (const front of fronts) {
+            const owner = front.state === "owned" ? ` → ${front.loudVendorIds[0]}` : "";
+            console.log(`${front.state.toUpperCase().padEnd(10)} ${front.claimId}${owner}`);
+        }
+        if (drift) {
+            console.log("");
+            if (drift.length === 0)
+                console.log(`No front changes since ${priorLabel}.`);
+            for (const change of drift)
+                console.log(`CHANGED   ${change.claimId}: ${change.before} → ${change.after}`);
+        }
+        return;
+    }
+    if (subcommand === "report") {
+        const set = await loadSet();
+        const format = option(rest, "--format") ?? "md";
+        const output = format === "html" ? marketMapToHtml(config, set) : marketMapToMarkdown(config, set);
+        const outPath = option(rest, "--out");
+        if (outPath) {
+            writeFileSync(resolve(process.cwd(), outPath), output);
+            console.log(`Wrote ${outPath}`);
+        }
+        else {
+            console.log(output);
+        }
+        return;
+    }
+    throw new Error(`Unknown market subcommand: ${subcommand} (try: init, capture, observe, fronts, report)`);
+}
 /**
  * The resolve gate: exit 0 = safe to create, exit 2 = match found (exists or
  * ambiguous — do NOT blind-create), exit 1 = error. Built for sync jobs and
@@ -1496,6 +1621,10 @@ export async function runCli(argv) {
         await resolveCommand(args);
         return;
     }
+    if (command === "market") {
+        await marketCommand(args);
+        return;
+    }
     if (command === "profiles") {
         profilesCommand(args);
         return;

package/dist/connectors/hubspot.js

@@ -334,7 +334,7 @@ export function createHubspotConnector(options) {
                         created = await request(`/crm/v3/objects/companies`, {
                             method: "POST",
                             body: JSON.stringify({
-                                properties: { name, hs_object_source_detail_2: "fullstackgtm create: operation" },
+                                properties: { name, hs_object_source_detail_2: `fullstackgtm create: (${operation.id})` },
                             }),
                         });
                     }

package/dist/index.d.ts

@@ -19,5 +19,7 @@ export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, s
 export { sampleSnapshot } from "./sampleData.ts";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, type CallScorecard, type LlmCredential, type LlmExtractedInsight, type LlmProvider, type Rubric, type ScoredDimension, } from "./llm.ts";
 export { resolveRecord, type ResolveCandidate, type ResolveMatch, type ResolveResult } from "./resolve.ts";
+export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadMarketConfig, marketHome, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, type CaptureEntry, type CaptureOptions, type ClaimFront, type ClaimIntensity, type FrontDrift, type FrontState, type MarketClaim, type MarketConfig, type MarketObservation, type MarketVendor, type ObservationConfidence, type ObservationSet, type ObservationStore, } from "./market.ts";
+export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.ts";
 export { suggestValues, type SuggestionConfidence, type ValueSuggestion } from "./suggest.ts";
 export type { ApprovalStatus, AuditFinding, AuditFindingSeverity, CanonicalAccount, CanonicalActivity, CanonicalContact, CanonicalDeal, CanonicalGtmSnapshot, CanonicalUser, CrmProvider, GtmAuditRule, GtmConnector, GtmEvidence, GtmEvidenceSourceSystem, GtmObjectType, GtmPolicy, GtmRuleContext, GtmRuleResult, GtmSnapshotIndex, PatchOperation, PatchOperationResult, PatchOperationType, PatchPlan, PatchPlanRun, PatchPlanRunStatus, PatchVerification, PipelineFinding, PipelineFindingStatus, PipelineFindingType, ProviderIdentity, RiskLevel, SourceFreshness, } from "./types.ts";

package/dist/index.js

@@ -19,4 +19,6 @@ export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, s
 export { sampleSnapshot } from "./sampleData.js";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
 export { resolveRecord } from "./resolve.js";
+export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadMarketConfig, marketHome, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, } from "./market.js";
+export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 export { suggestValues } from "./suggest.js";

package/dist/market.d.ts

@@ -0,0 +1,147 @@
+import type { GtmEvidence } from "./types.ts";
+/**
+ * The Market Map: a live model of the competitive category a company sells
+ * into. Vendors publish claims constantly (pricing pages, feature pages,
+ * hero copy); each (vendor × claim) cell gets a messaging-intensity reading,
+ * and each claim row gets a derived front state. Observations are
+ * append-only — history is the product; "what changed since last run" is a
+ * first-class question.
+ *
+ * Division of labor mirrors call intelligence: intensity readings are
+ * *proposals* (LLM or human, always with verbatim quoted evidence), while
+ * everything downstream — front states, drift, the report — is deterministic
+ * over the stored observations. Same stored observations, same map.
+ *
+ * The claim taxonomy and vendor registry live in a reviewable config file
+ * (git-friendly, analyst-edited); captures and observations live under the
+ * profile home so one client's category intel never bleeds into another's.
+ */
+export type ClaimIntensity = "loud" | "quiet" | "absent" | "unobservable";
+export type ObservationConfidence = "high" | "medium" | "low";
+export type FrontState = "open" | "contested" | "owned" | "saturated" | "vacant";
+export type MarketClaim = {
+    id: string;
+    /** The capability being claimed, precise enough to judge loud/quiet/absent. */
+    capability: string;
+    /** Which ICP the claim cell addresses (category-specific vocabulary). */
+    icp: string;
+    /** Which pricing structure the claim cell implies (category-specific). */
+    pricingStructure: string;
+    /** Operational definition: how a reader judges LOUD vs QUIET vs ABSENT. */
+    definition: string;
+};
+export type MarketVendor = {
+    id: string;
+    name: string;
+    urls: {
+        home: string;
+        /** null is itself an observation: no public pricing surface. */
+        pricing: string | null;
+        product: string[];
+    };
+    notes?: string;
+};
+export type MarketConfig = {
+    category: string;
+    anchorVendor?: string;
+    vendors: MarketVendor[];
+    claims: MarketClaim[];
+    /** The LOUD/QUIET/ABSENT/UNOBSERVABLE judging rule, stated for reviewers. */
+    surfaceRule?: string;
+};
+export type MarketObservation = {
+    /** stableHash(category, runLabel, vendorId, claimId) — deterministic. */
+    id: string;
+    vendorId: string;
+    claimId: string;
+    observedAt: string;
+    intensity: ClaimIntensity;
+    confidence: ObservationConfidence;
+    /** Reviewer-facing: why the reading is what it is. */
+    reason: string;
+    /**
+     * Verbatim quoted spans grounding any non-absent reading
+     * (sourceSystem "web", metadata.url + metadata.captureHash).
+     */
+    evidence: GtmEvidence[];
+};
+export type ObservationSet = {
+    id: string;
+    category: string;
+    runLabel: string;
+    runAt: string;
+    /** What produced the readings: "manual" or "llm:<provider>:<model>". */
+    extractor: string;
+    observations: MarketObservation[];
+};
+export type CaptureEntry = {
+    runLabel: string;
+    vendorId: string;
+    kind: "home" | "pricing" | "product";
+    url: string;
+    fetchedAt: string;
+    httpStatus: number | null;
+    /** sha256 of the extracted text; null when the fetch failed or was empty. */
+    captureHash: string | null;
+    textChars: number;
+};
+export declare function observationId(category: string, runLabel: string, vendorId: string, claimId: string): string;
+export declare function parseMarketConfig(raw: string): MarketConfig;
+export declare function loadMarketConfig(path: string): MarketConfig;
+export declare function starterMarketConfig(category: string): MarketConfig;
+export declare function marketHome(category: string, baseDir?: string): string;
+export declare function extractReadableText(html: string): string;
+export type FetchPage = (url: string) => Promise<{
+    status: number;
+    body: string;
+}>;
+export type CaptureOptions = {
+    /** Directory for captures; defaults to <marketHome>/captures. */
+    dir?: string;
+    runLabel?: string;
+    /** Injectable for tests; defaults to global fetch. */
+    fetchPage?: FetchPage;
+    now?: () => Date;
+};
+export type CaptureResult = {
+    entries: CaptureEntry[];
+    manifestPath: string;
+};
+export declare function captureMarket(config: MarketConfig, options?: CaptureOptions): Promise<CaptureResult>;
+export interface ObservationStore {
+    append(set: ObservationSet): Promise<ObservationSet>;
+    get(runLabel: string): Promise<ObservationSet | null>;
+    list(): Promise<Array<{
+        runLabel: string;
+        runAt: string;
+        observations: number;
+    }>>;
+    latest(): Promise<ObservationSet | null>;
+}
+export declare function createFileObservationStore(category: string, directory?: string): ObservationStore;
+/**
+ * Validate a proposed observation set against the config before it enters
+ * the store: known vendors/claims, full coverage, legal readings, and the
+ * verbatim-evidence rule (non-absent readings must quote something).
+ * Returns problems; an empty array means accept.
+ */
+export declare function validateObservationSet(config: MarketConfig, set: ObservationSet): string[];
+export type ClaimFront = {
+    claimId: string;
+    state: FrontState;
+    loudVendorIds: string[];
+    quietVendorIds: string[];
+};
+/**
+ * Front rule v1: 0 loud → open (if anyone is quiet) or vacant; 1 loud →
+ * owned; 2–3 loud → contested; ≥4 loud → saturated. Unobservable cells are
+ * excluded — a failed capture never reads as absence.
+ */
+export declare function computeFrontStates(config: MarketConfig, set: ObservationSet): ClaimFront[];
+export type FrontDrift = {
+    claimId: string;
+    before: FrontState;
+    after: FrontState;
+};
+/** What changed in the category between two runs — the refresh's whole point. */
+export declare function diffFrontStates(before: ClaimFront[], after: ClaimFront[]): FrontDrift[];