fullstackgtm 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -5,6 +5,39 @@ 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.18.0] — 2026-06-11
+
+Axis discovery: earn a strategic 2×2 from the observations instead of
+asserting one.
+
+### Added
+
+- **Axes as config** — `axes` in `market.config.json`: each axis is a
+  claim-scoring rubric (`{ id, label, poles, rubric, status, claimScores }`,
+  null = axis doesn't apply to that claim); a vendor's position is the
+  intensity-weighted mean (loud=1, quiet=½) of the claims it voices.
+  `primaryAxes: [x, y]` picks the report's strategic map. Config validation
+  rejects axes scoring unknown claims.
+- **`fullstackgtm market axes`** — the discovery math, pure and
+  dependency-free: PCA (power iteration) over the vendor × claim intensity
+  matrix — PC1 is the category's own primary axis, PC2 the
+  maximum-differentiation direction orthogonal to it; triangulation of every
+  configured axis against the PCs (a real axis is *derivable* from the data,
+  not just felt); and an orthogonality screen (|r| ≥ 0.75 = one axis twice —
+  sometimes the finding: the category couples the ideas and the empty
+  quadrant is the white space). Fully-unobservable vendors are excluded,
+  never zeroed.
+- **Report: strategic map** — section 03 renders the primary 2×2 (positions
+  computed, not asserted; dot size = LOUD count; axis status in the caption)
+  when axes are configured; the evidence appendix renumbers accordingly. The
+  report deliberately carries only the one earned 2×2 — best foot forward
+  for the client; axis exploration (every pairing, r, verdicts) is `market
+  axes` territory for the analyst or agent doing the iterating.
+- **Golden regression**: the 280-cell creative-intelligence validation
+  dataset ships as a test fixture — PCA must recover the buyer axis as PC1
+  (|r| ≥ 0.9) and value-mode as PC2 (|r| ≥ 0.85), and flag the documented
+  buyer × operating-model redundancy.
+
 ## [0.17.0] — 2026-06-11
 
 Market map classification: intensity readings become a one-command step, and

package/INSTALL_FOR_AGENTS.md

@@ -49,11 +49,16 @@ In an agent sandbox, prefer rung 1 or 2. Never echo tokens into argv —
 environments — login flows then print verification URLs instead of opening
 the OS browser.
 
-LLM calls (`call parse`, `call score`): set `ANTHROPIC_API_KEY` or
-`OPENAI_API_KEY` in the environment, or have the human run
-`echo "$KEY" | fullstackgtm login anthropic` once. Without a key, use
-`call parse --deterministic` (free keyword baseline, no prompt). In
-non-interactive contexts the CLI never prompts — it fails with this guidance.
+LLM calls (`call parse`, `call score`, `market classify`): set
+`ANTHROPIC_API_KEY` or `OPENAI_API_KEY` in the environment, or have the human
+run `echo "$KEY" | fullstackgtm login anthropic` once. Without a key, use
+`call parse --deterministic` (free keyword baseline, no prompt) — or, for the
+market map, classify it yourself: `fullstackgtm market worksheet --vendor <id>`
+returns the claims, judging rules, and captured page texts; submit your
+readings via `market observe --from <file>`. Quote evidence VERBATIM from the
+page texts — every span is checked character-for-character against the stored
+capture, and paraphrased quotes are rejected. In non-interactive contexts the
+CLI never prompts — it fails with this guidance.
 
 Provider prerequisites (what the human must create, and which scopes) are in
 the README's **"Connect your CRM"** section: HubSpot needs a private app with

package/README.md

@@ -109,6 +109,23 @@ npx fullstackgtm report --provider hubspot --client "Acme" --out acme-health.htm
 
 `report` renders the same audit as a deliverable — severity counts up front, a prose summary, per-rule detail with example records, and next steps — as markdown or self-contained HTML (printable, emailable, no external assets).
 
+## The market map: the category, observed
+
+Your CRM records what happened in your own deals; nothing records the shape of the category you sell into. The **market map** does: vendors and a claim taxonomy live in a reviewable `market.config.json`, vendor pages are captured into a content-addressed cache, every vendor × claim cell gets a messaging-intensity reading (LOUD / QUIET / ABSENT — with UNOBSERVABLE for failed captures, never a fake absence), and deterministic front states fall out per claim: open, contested, owned, saturated.
+
+```bash
+fullstackgtm market init --category creative-intelligence   # seed vendors + claims, edit by hand
+fullstackgtm market capture                                 # fetch pages → content-addressed captures
+fullstackgtm market classify                                # LLM readings (BYO key), every quote verified
+fullstackgtm market fronts --diff run-1                     # what changed since last run
+fullstackgtm market report --format html --out map.html     # the client-ready field report
+fullstackgtm market refresh                                 # all of the above, weekly, one command
+```
+
+The discipline matches the rest of the tool. Intensity readings are *proposals* — from the LLM (`classify`, same bring-your-own-key seam as `call parse`, provenance-marked) or from any agent/human (`market worksheet` → `market observe`) — and **every quoted evidence span is verified character-for-character against the stored capture it cites** before an observation is accepted. Quotes that aren't on the page bounce. Everything downstream of the store is deterministic: same observations, same map.
+
+`market axes` is for earning a strategic 2×2 instead of asserting one: PCA over the intensity matrix (PC1 = the category's own primary axis, PC2 = the most differentiating direction orthogonal to it), triangulation of your configured axes against the data, and an orthogonality screen that flags two axes that are secretly one. Axes are claim-scoring rubrics in the config; the report renders the primary pair as the strategic map. Captures and observations are profile-scoped (`~/.fullstackgtm/market/<category>`), so one client's category intel never bleeds into another's.
+
 ### Working across organizations
 
 Consultants and fractional operators hold credentials for several CRMs at once. A profile scopes stored logins *and* stored plans to one organization:

package/dist/cli.js

@@ -19,6 +19,7 @@ import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall, suggestCallDeal } from "./calls.js";
 import { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, loadCaptureTexts, loadMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
+import { assessAxes, axesReportToText } from "./marketAxes.js";
 import { buildWorksheet, classifyMarket } from "./marketClassify.js";
 import { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 import { DEFAULT_RUBRIC, detectProviderFromKey, extractInsightsLlm, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";
@@ -64,6 +65,7 @@ Usage:
   fullstackgtm market worksheet --vendor <id> [--out <path>]
   fullstackgtm market observe --from <observations.json> [--unverified]
   fullstackgtm market fronts [--run <label>] [--diff <prior-run>] [--json]
+  fullstackgtm market axes [--run <label>] [--json]
   fullstackgtm market report [--run <label>] [--format md|html] [--out <path>]
   fullstackgtm market refresh [--run <label>] [--model m]
                                                the live competitive map: capture vendor pages (content-addressed),
@@ -757,9 +759,17 @@ market classify [--run <label>] [--capture-run <label>] [--vendor <id>] [--model
 market worksheet --vendor <id> [--capture-run <label>] [--out <path>]
 market observe --from <observations.json> [--unverified]
 market fronts [--config <path>] [--run <label>] [--diff <prior-run>] [--json]
+market axes [--config <path>] [--run <label>] [--json]
 market report [--config <path>] [--run <label>] [--format md|html] [--out <path>]
 market refresh [--run <label>] [--model m]     capture → classify → fronts drift → HTML report
 
+axes runs the axis-discovery math: PCA over the vendor × claim intensity
+matrix (PC1 = the category's primary axis, PC2 = the max-differentiation
+direction orthogonal to it), triangulation of configured axes against the
+PCs, and an orthogonality screen (|r|>0.75 = one axis twice). Axes live in
+the config as claim-scoring rubrics; the report's strategic map and axis
+lab render from them.
+
 classify uses your Anthropic/OpenAI key (like call parse) to read the stored
 captures and propose intensity readings; worksheet is the no-key path (an
 agent or human fills it, submits via observe). Either way, every quoted span
@@ -947,7 +957,17 @@ recomputed deterministically on every invocation — never stored.`);
         }
         return;
     }
-    throw new Error(`Unknown market subcommand: ${subcommand} (try: init, capture, classify, worksheet, observe, fronts, report, refresh)`);
+    if (subcommand === "axes") {
+        const set = await loadSet();
+        const report = assessAxes(config, set);
+        if (rest.includes("--json")) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(axesReportToText(report));
+        return;
+    }
+    throw new Error(`Unknown market subcommand: ${subcommand} (try: init, capture, classify, worksheet, observe, fronts, axes, report, refresh)`);
 }
 /**
  * The resolve gate: exit 0 = safe to create, exit 2 = match found (exists or

package/dist/index.d.ts

@@ -19,7 +19,8 @@ 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, loadCaptureTexts, loadMarketConfig, marketHome, normalizeForMatch, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, 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, type SpanVerificationFailure, } from "./market.ts";
+export { captureMarket, computeFrontStates, createFileObservationStore, diffFrontStates, extractReadableText, loadCaptureTexts, loadMarketConfig, marketHome, normalizeForMatch, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, type CaptureEntry, type CaptureOptions, type ClaimFront, type ClaimIntensity, type FrontDrift, type FrontState, type MarketAxis, type MarketClaim, type MarketConfig, type MarketObservation, type MarketVendor, type ObservationConfidence, type ObservationSet, type ObservationStore, type SpanVerificationFailure, } from "./market.ts";
+export { assessAxes, axesReportToText, axisPosition, messageBreadth, pcaTop2, pearson, type AxesReport, type AxisAssessment, type AxisPairing, type PrincipalComponent, } from "./marketAxes.ts";
 export { buildWorksheet, classifyMarket, type ClassifyMarketOptions, type ClassifyMarketResult, type MarketWorksheet, } from "./marketClassify.ts";
 export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.ts";
 export { suggestValues, type SuggestionConfidence, type ValueSuggestion } from "./suggest.ts";

package/dist/index.js

@@ -20,6 +20,7 @@ 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, loadCaptureTexts, loadMarketConfig, marketHome, normalizeForMatch, observationId, parseMarketConfig, starterMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
+export { assessAxes, axesReportToText, axisPosition, messageBreadth, pcaTop2, pearson, } from "./marketAxes.js";
 export { buildWorksheet, classifyMarket, } from "./marketClassify.js";
 export { marketMapToHtml, marketMapToMarkdown } from "./marketReport.js";
 export { suggestValues } from "./suggest.js";

package/dist/market.d.ts

@@ -41,6 +41,18 @@ export type MarketVendor = {
     };
     notes?: string;
 };
+export type MarketAxis = {
+    id: string;
+    label: string;
+    negativePole: string;
+    positivePole: string;
+    /** How a human scores a claim on this axis — the axis IS this rubric. */
+    rubric: string;
+    /** e.g. "validated", "proposal", "proposal (PC2-validated)". Reviewer-facing. */
+    status?: string;
+    /** claimId → score in [-1, 1]; null = the axis does not apply to this claim. */
+    claimScores: Record<string, number | null>;
+};
 export type MarketConfig = {
     category: string;
     anchorVendor?: string;
@@ -48,6 +60,10 @@ export type MarketConfig = {
     claims: MarketClaim[];
     /** The LOUD/QUIET/ABSENT/UNOBSERVABLE judging rule, stated for reviewers. */
     surfaceRule?: string;
+    /** Strategic axes as claim-scoring rubrics — config, not code. */
+    axes?: MarketAxis[];
+    /** [xAxisId, yAxisId] for the report's strategic map. */
+    primaryAxes?: [string, string];
 };
 export type MarketObservation = {
     /** stableHash(category, runLabel, vendorId, claimId) — deterministic. */

package/dist/market.js

@@ -49,6 +49,30 @@ export function parseMarketConfig(raw) {
     if (config.anchorVendor && !config.vendors.some((v) => v.id === config.anchorVendor)) {
         throw new Error(`market config: anchorVendor "${config.anchorVendor}" is not in vendors`);
     }
+    if (config.axes) {
+        const claimIds = new Set(config.claims.map((claim) => claim.id));
+        const axisIds = new Set();
+        for (const axis of config.axes) {
+            if (!axis.id)
+                throw new Error("market config: axis missing id");
+            if (axisIds.has(axis.id))
+                throw new Error(`market config: duplicate axis id "${axis.id}"`);
+            axisIds.add(axis.id);
+            for (const claimId of Object.keys(axis.claimScores ?? {})) {
+                if (!claimIds.has(claimId)) {
+                    throw new Error(`market config: axis "${axis.id}" scores unknown claim "${claimId}"`);
+                }
+            }
+        }
+        if (config.primaryAxes) {
+            if (config.primaryAxes.length !== 2 || config.primaryAxes.some((id) => !axisIds.has(id))) {
+                throw new Error(`market config: primaryAxes must name two configured axes (got ${JSON.stringify(config.primaryAxes)})`);
+            }
+        }
+    }
+    else if (config.primaryAxes) {
+        throw new Error("market config: primaryAxes set but no axes configured");
+    }
     return config;
 }
 export function loadMarketConfig(path) {

package/dist/marketAxes.d.ts

@@ -0,0 +1,77 @@
+import type { MarketAxis, MarketConfig, MarketObservation, ObservationSet } from "./market.ts";
+/**
+ * Axis discovery for a market map — the method that earns a strategic 2x2
+ * instead of asserting one. Axes are claim-scoring rubrics in the config
+ * (reviewable, versioned); a vendor's position on an axis is the
+ * intensity-weighted mean of the scores of claims it voices. Two checks keep
+ * axes honest, both computed deterministically from the stored observations:
+ *
+ *  1. Triangulation — PCA over the vendor × claim intensity matrix gives the
+ *     category's own top variance directions; a real axis correlates with a
+ *     principal component (it is derivable from the data, not just felt).
+ *  2. Orthogonality — two configured axes that correlate ≥ ~0.75 at the
+ *     vendor level are one axis twice. Sometimes that redundancy is the
+ *     finding: the category couples the two ideas, and the empty quadrant is
+ *     the strategic white space.
+ *
+ * Everything here is pure math over the store: same observations, same map.
+ */
+export declare const VOICE_WEIGHT: Record<string, number>;
+/**
+ * Intensity-weighted mean of claim scores over claims the vendor voices.
+ * Claims scored null on the axis are excluded; returns null if the vendor
+ * voices nothing scoreable (e.g. fully unobservable).
+ */
+export declare function axisPosition(vendorId: string, claimScores: Record<string, number | null>, observations: MarketObservation[]): number | null;
+/** Share of the claim space voiced (loud + half-weight quiet) over observable claims. */
+export declare function messageBreadth(vendorId: string, observations: MarketObservation[]): {
+    breadth: number | null;
+    loudCount: number;
+};
+export declare function pearson(xs: number[], ys: number[]): number;
+export type PrincipalComponent = {
+    /** claimId → loading. Sign is arbitrary; read poles from the extremes. */
+    loadings: Array<{
+        claimId: string;
+        loading: number;
+    }>;
+    /** vendorId → score on this component. */
+    scores: Array<{
+        vendorId: string;
+        score: number;
+    }>;
+};
+export declare function pcaTop2(config: MarketConfig, set: ObservationSet): {
+    vendors: string[];
+    pc1: PrincipalComponent;
+    pc2: PrincipalComponent;
+};
+export type AxisVendorPosition = {
+    vendorId: string;
+    position: number | null;
+};
+export type AxisAssessment = {
+    axis: MarketAxis;
+    positions: AxisVendorPosition[];
+    /** Standard deviation of placeable vendor positions — does the axis separate anyone? */
+    spread: number;
+    rVsPc1: number;
+    rVsPc2: number;
+};
+export type AxisPairing = {
+    aId: string;
+    bId: string;
+    r: number;
+    verdict: "near-orthogonal" | "correlated — weak pair" | "redundant — same axis twice";
+};
+export type AxesReport = {
+    vendors: string[];
+    pc1: PrincipalComponent;
+    pc2: PrincipalComponent;
+    assessments: AxisAssessment[];
+    /** Includes the derived breadth axis in pairings. */
+    pairings: AxisPairing[];
+};
+export declare function pairingVerdict(r: number): AxisPairing["verdict"];
+export declare function assessAxes(config: MarketConfig, set: ObservationSet): AxesReport;
+export declare function axesReportToText(report: AxesReport): string;

package/dist/marketAxes.js

@@ -0,0 +1,199 @@
+/**
+ * Axis discovery for a market map — the method that earns a strategic 2x2
+ * instead of asserting one. Axes are claim-scoring rubrics in the config
+ * (reviewable, versioned); a vendor's position on an axis is the
+ * intensity-weighted mean of the scores of claims it voices. Two checks keep
+ * axes honest, both computed deterministically from the stored observations:
+ *
+ *  1. Triangulation — PCA over the vendor × claim intensity matrix gives the
+ *     category's own top variance directions; a real axis correlates with a
+ *     principal component (it is derivable from the data, not just felt).
+ *  2. Orthogonality — two configured axes that correlate ≥ ~0.75 at the
+ *     vendor level are one axis twice. Sometimes that redundancy is the
+ *     finding: the category couples the two ideas, and the empty quadrant is
+ *     the strategic white space.
+ *
+ * Everything here is pure math over the store: same observations, same map.
+ */
+export const VOICE_WEIGHT = { loud: 1.0, quiet: 0.5 };
+/**
+ * Intensity-weighted mean of claim scores over claims the vendor voices.
+ * Claims scored null on the axis are excluded; returns null if the vendor
+ * voices nothing scoreable (e.g. fully unobservable).
+ */
+export function axisPosition(vendorId, claimScores, observations) {
+    let num = 0;
+    let den = 0;
+    for (const obs of observations) {
+        if (obs.vendorId !== vendorId)
+            continue;
+        const score = claimScores[obs.claimId];
+        if (score === null || score === undefined)
+            continue;
+        const weight = VOICE_WEIGHT[obs.intensity] ?? 0;
+        if (weight > 0) {
+            num += score * weight;
+            den += weight;
+        }
+    }
+    return den > 0 ? num / den : null;
+}
+/** Share of the claim space voiced (loud + half-weight quiet) over observable claims. */
+export function messageBreadth(vendorId, observations) {
+    let voiced = 0;
+    let observable = 0;
+    let loudCount = 0;
+    for (const obs of observations) {
+        if (obs.vendorId !== vendorId)
+            continue;
+        if (obs.intensity === "unobservable")
+            continue;
+        observable += 1;
+        voiced += VOICE_WEIGHT[obs.intensity] ?? 0;
+        if (obs.intensity === "loud")
+            loudCount += 1;
+    }
+    return { breadth: observable > 0 ? voiced / observable : null, loudCount };
+}
+export function pearson(xs, ys) {
+    const n = xs.length;
+    if (n < 3)
+        return 0;
+    const mx = xs.reduce((sum, x) => sum + x, 0) / n;
+    const my = ys.reduce((sum, y) => sum + y, 0) / n;
+    const sx = Math.sqrt(xs.reduce((sum, x) => sum + (x - mx) ** 2, 0));
+    const sy = Math.sqrt(ys.reduce((sum, y) => sum + (y - my) ** 2, 0));
+    if (!sx || !sy)
+        return 0;
+    return xs.reduce((sum, x, i) => sum + (x - mx) * (ys[i] - my), 0) / (sx * sy);
+}
+export function pcaTop2(config, set) {
+    const claimIds = config.claims.map((claim) => claim.id);
+    const byCell = new Map(set.observations.map((obs) => [`${obs.vendorId}|${obs.claimId}`, obs]));
+    // Exclude fully-unobservable vendors: they carry no information, only zeros.
+    const vendors = config.vendors
+        .map((vendor) => vendor.id)
+        .filter((vendorId) => claimIds.some((claimId) => {
+        const obs = byCell.get(`${vendorId}|${claimId}`);
+        return obs !== undefined && obs.intensity !== "unobservable";
+    }));
+    const matrix = vendors.map((vendorId) => claimIds.map((claimId) => VOICE_WEIGHT[byCell.get(`${vendorId}|${claimId}`)?.intensity ?? ""] ?? 0));
+    const means = claimIds.map((_, j) => matrix.reduce((sum, row) => sum + row[j], 0) / vendors.length);
+    const centered = matrix.map((row) => row.map((value, j) => value - means[j]));
+    const component = (deflate) => {
+        let v = new Array(claimIds.length).fill(1 / Math.sqrt(claimIds.length));
+        for (let iteration = 0; iteration < 300; iteration += 1) {
+            if (deflate) {
+                const dot = v.reduce((sum, x, k) => sum + x * deflate[k], 0);
+                v = v.map((x, k) => x - dot * deflate[k]);
+            }
+            const scores = centered.map((row) => row.reduce((sum, x, j) => sum + x * v[j], 0));
+            v = claimIds.map((_, j) => centered.reduce((sum, row, i) => sum + row[j] * scores[i], 0));
+            const norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0)) || 1;
+            v = v.map((x) => x / norm);
+        }
+        return { loadings: v, scores: centered.map((row) => row.reduce((sum, x, j) => sum + x * v[j], 0)) };
+    };
+    const first = component();
+    const second = component(first.loadings);
+    const shape = (raw) => ({
+        loadings: claimIds.map((claimId, j) => ({ claimId, loading: raw.loadings[j] })),
+        scores: vendors.map((vendorId, i) => ({ vendorId, score: raw.scores[i] })),
+    });
+    return { vendors, pc1: shape(first), pc2: shape(second) };
+}
+export function pairingVerdict(r) {
+    const magnitude = Math.abs(r);
+    if (magnitude < 0.4)
+        return "near-orthogonal";
+    if (magnitude < 0.75)
+        return "correlated — weak pair";
+    return "redundant — same axis twice";
+}
+export function assessAxes(config, set) {
+    const { vendors, pc1, pc2 } = pcaTop2(config, set);
+    const pcScore = (pc) => new Map(pc.scores.map((entry) => [entry.vendorId, entry.score]));
+    const pc1ByVendor = pcScore(pc1);
+    const pc2ByVendor = pcScore(pc2);
+    const axes = config.axes ?? [];
+    const positionsById = new Map();
+    const assessments = axes.map((axis) => {
+        const positions = vendors.map((vendorId) => ({
+            vendorId,
+            position: axisPosition(vendorId, axis.claimScores, set.observations),
+        }));
+        const placeable = positions.filter((entry) => entry.position !== null);
+        positionsById.set(axis.id, new Map(placeable.map((entry) => [entry.vendorId, entry.position])));
+        const values = placeable.map((entry) => entry.position);
+        const mean = values.reduce((sum, x) => sum + x, 0) / Math.max(values.length, 1);
+        const spread = Math.sqrt(values.reduce((sum, x) => sum + (x - mean) ** 2, 0) / Math.max(values.length, 1));
+        const aligned = placeable.filter((entry) => pc1ByVendor.has(entry.vendorId));
+        return {
+            axis,
+            positions,
+            spread,
+            rVsPc1: pearson(aligned.map((entry) => entry.position), aligned.map((entry) => pc1ByVendor.get(entry.vendorId))),
+            rVsPc2: pearson(aligned.map((entry) => entry.position), aligned.map((entry) => pc2ByVendor.get(entry.vendorId))),
+        };
+    });
+    // Derived breadth axis joins the orthogonality screen (it's free and often
+    // the only near-orthogonal partner early on).
+    const breadthPositions = new Map();
+    for (const vendorId of vendors) {
+        const { breadth } = messageBreadth(vendorId, set.observations);
+        if (breadth !== null)
+            breadthPositions.set(vendorId, breadth);
+    }
+    positionsById.set("breadth", breadthPositions);
+    const ids = [...axes.map((axis) => axis.id), "breadth"];
+    const pairings = [];
+    for (let i = 0; i < ids.length; i += 1) {
+        for (let j = i + 1; j < ids.length; j += 1) {
+            const a = positionsById.get(ids[i]);
+            const b = positionsById.get(ids[j]);
+            const shared = vendors.filter((vendorId) => a.has(vendorId) && b.has(vendorId));
+            const r = pearson(shared.map((vendorId) => a.get(vendorId)), shared.map((vendorId) => b.get(vendorId)));
+            pairings.push({ aId: ids[i], bId: ids[j], r, verdict: pairingVerdict(r) });
+        }
+    }
+    return { vendors, pc1, pc2, assessments, pairings };
+}
+export function axesReportToText(report) {
+    const lines = [];
+    for (const [label, pc] of [
+        ["PC1", report.pc1],
+        ["PC2", report.pc2],
+    ]) {
+        lines.push(`=== ${label} — claim loadings (extremes; sign is arbitrary, read the poles) ===`);
+        const ordered = [...pc.loadings].sort((a, b) => a.loading - b.loading);
+        for (const entry of ordered.slice(0, 5)) {
+            lines.push(`  ${entry.loading >= 0 ? "+" : ""}${entry.loading.toFixed(2)}  ${entry.claimId}`);
+        }
+        lines.push("   ...");
+        for (const entry of ordered.slice(-5)) {
+            lines.push(`  ${entry.loading >= 0 ? "+" : ""}${entry.loading.toFixed(2)}  ${entry.claimId}`);
+        }
+        lines.push(`  vendor scores: ${[...pc.scores]
+            .sort((a, b) => a.score - b.score)
+            .map((entry) => `${entry.vendorId}=${entry.score >= 0 ? "+" : ""}${entry.score.toFixed(2)}`)
+            .join("  ")}`);
+        lines.push("");
+    }
+    if (report.assessments.length > 0) {
+        lines.push("=== configured axes vs PCA (triangulation: a real axis is derivable from the data) ===");
+        for (const assessment of report.assessments) {
+            lines.push(`  ${assessment.axis.id.padEnd(20)} spread=${assessment.spread.toFixed(3)}  r(PC1)=${assessment.rVsPc1 >= 0 ? "+" : ""}${assessment.rVsPc1.toFixed(2)}  r(PC2)=${assessment.rVsPc2 >= 0 ? "+" : ""}${assessment.rVsPc2.toFixed(2)}  [${assessment.axis.status ?? ""}]`);
+        }
+        lines.push("");
+        lines.push("=== orthogonality screen (|r|>0.75 = redundant pair) ===");
+        for (const pairing of report.pairings) {
+            const flag = pairing.verdict === "redundant — same axis twice" ? "  <-- redundant" : "";
+            lines.push(`  ${pairing.aId.padEnd(18)} x ${pairing.bId.padEnd(18)} r=${pairing.r >= 0 ? "+" : ""}${pairing.r.toFixed(2)}${flag}`);
+        }
+    }
+    else {
+        lines.push("No axes configured. Read the PC loadings above, name the two directions, and add them");
+        lines.push("to market.config.json as axes: [{ id, label, negativePole, positivePole, rubric, claimScores }].");
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/marketReport.js

@@ -1,4 +1,5 @@
 import { computeFrontStates } from "./market.js";
+import { assessAxes, messageBreadth } from "./marketAxes.js";
 /**
  * Render a market map as a client-ready deliverable: markdown for terminals
  * and PRs, and a self-contained printable HTML "field report" — front
@@ -77,6 +78,107 @@ export function marketMapToMarkdown(config, set) {
     }
     return `${lines.join("\n")}\n`;
 }
+function svgScatter(points, ax, ay, anchor, mini) {
+    const W = mini ? 330 : 700;
+    const H = mini ? 250 : 460;
+    const PAD = mini ? 34 : 56;
+    const range = (axis, values) => {
+        if (axis.signed)
+            return [-1.1, 1.1];
+        if (values.length === 0)
+            return [0, 1];
+        return [Math.min(0, Math.min(...values) - 0.05), Math.max(...values) + 0.08];
+    };
+    const [xLo, xHi] = range(ax, points.map((p) => p.x));
+    const [yLo, yHi] = range(ay, points.map((p) => p.y));
+    const sx = (x) => PAD + ((x - xLo) / (xHi - xLo)) * (W - 2 * PAD);
+    const sy = (y) => H - PAD - ((y - yLo) / (yHi - yLo)) * (H - 2 * PAD);
+    const fsLabel = mini ? 8.5 : 10.5;
+    const fsAx = mini ? 8 : 10;
+    const e = escapeHtml;
+    const dots = points
+        .map((p) => {
+        const r = mini ? 3 + p.loud * 0.8 : 6 + p.loud * 1.6;
+        const cls = p.vendorId === anchor ? "dot-anchor" : "dot";
+        return (`<circle class="${cls}" cx="${sx(p.x).toFixed(1)}" cy="${sy(p.y).toFixed(1)}" r="${r.toFixed(1)}"/>` +
+            `<text class="dot-label" style="font-size:${fsLabel}px" x="${sx(p.x).toFixed(1)}" y="${(sy(p.y) - r - 4).toFixed(1)}">${e(p.name)}</text>`);
+    })
+        .join("");
+    const midX = ax.signed ? `<line class="axis-mid" x1="${sx(0).toFixed(0)}" y1="${PAD}" x2="${sx(0).toFixed(0)}" y2="${H - PAD}"/>` : "";
+    const midY = ay.signed ? `<line class="axis-mid" x1="${PAD}" y1="${sy(0).toFixed(0)}" x2="${W - PAD}" y2="${sy(0).toFixed(0)}"/>` : "";
+    return `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${e(ax.label)} vs ${e(ay.label)}">
+    <line class="axis" x1="${PAD}" y1="${H - PAD}" x2="${W - PAD}" y2="${H - PAD}"/>
+    <line class="axis" x1="${PAD}" y1="${PAD}" x2="${PAD}" y2="${H - PAD}"/>${midX}${midY}
+    <text class="ax-label" style="font-size:${fsAx}px" x="${PAD}" y="${H - 14}">&#8592; ${e(ax.negativePole)}</text>
+    <text class="ax-label" style="font-size:${fsAx}px" x="${W - PAD}" y="${H - 14}" text-anchor="end">${e(ax.positivePole)} &#8594;</text>
+    <text class="ax-label" style="font-size:${fsAx}px" x="${PAD}" y="${PAD - 10}">&#8593; ${e(ay.positivePole)}${ay.signed ? ` &#183; &#8595; ${e(ay.negativePole)}` : ""}</text>
+    ${dots}</svg>`;
+}
+function axisSectionsHtml(config, set) {
+    const axes = config.axes ?? [];
+    if (axes.length === 0)
+        return { strategicMap: "", report: null };
+    const e = escapeHtml;
+    const report = assessAxes(config, set);
+    const vendorNames = new Map(config.vendors.map((vendor) => [vendor.id, vendor.name]));
+    const loudCounts = new Map(report.vendors.map((vendorId) => [vendorId, messageBreadth(vendorId, set.observations).loudCount]));
+    const breadthAxis = {
+        id: "breadth",
+        label: "Message breadth",
+        negativePole: "FOCUSED",
+        positivePole: "BROAD (share of claims voiced)",
+        signed: false,
+    };
+    const axisInfo = new Map([
+        ...axes.map((axis) => [axis.id, { id: axis.id, label: axis.label, negativePole: axis.negativePole, positivePole: axis.positivePole, signed: true }]),
+        [breadthAxis.id, breadthAxis],
+    ]);
+    const positions = new Map();
+    for (const assessment of report.assessments) {
+        positions.set(assessment.axis.id, new Map(assessment.positions
+            .filter((entry) => entry.position !== null)
+            .map((entry) => [entry.vendorId, entry.position])));
+    }
+    const breadthMap = new Map();
+    for (const vendorId of report.vendors) {
+        const { breadth } = messageBreadth(vendorId, set.observations);
+        if (breadth !== null)
+            breadthMap.set(vendorId, breadth);
+    }
+    positions.set("breadth", breadthMap);
+    const pointsFor = (xId, yId) => {
+        const xs = positions.get(xId);
+        const ys = positions.get(yId);
+        if (!xs || !ys)
+            return [];
+        return report.vendors
+            .filter((vendorId) => xs.has(vendorId) && ys.has(vendorId))
+            .map((vendorId) => ({
+            vendorId,
+            name: vendorNames.get(vendorId) ?? vendorId,
+            x: xs.get(vendorId),
+            y: ys.get(vendorId),
+            loud: loudCounts.get(vendorId) ?? 0,
+        }));
+    };
+    const [px, py] = config.primaryAxes ?? [axes[0].id, axes[1]?.id ?? "breadth"];
+    const axInfo = axisInfo.get(px);
+    const ayInfo = axisInfo.get(py);
+    const statusOf = (id) => axes.find((axis) => axis.id === id)?.status ?? (id === "breadth" ? "derived" : "");
+    const strategicMap = `<section>
+  <h2><span class="no">03</span> Strategic map — ${e(axInfo.label)} &#215; ${e(ayInfo.label)}</h2>
+  <figure>${svgScatter(pointsFor(px, py), axInfo, ayInfo, config.anchorVendor, false)}
+  <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. Dot size = LOUD count. Axis status — ${e(axInfo.label)}: ${e(statusOf(px))}; ${e(ayInfo.label)}: ${e(statusOf(py))}.</figcaption>
+  </figure>
+</section>`;
+    // Deliberately no axis-pairing gallery here: the report is the client-facing
+    // artifact, best foot forward — one earned 2x2. Axis exploration (PCA,
+    // triangulation, the orthogonality screen over every pairing) lives in
+    // `market axes` for the analyst or agent doing the iterating.
+    return { strategicMap, report };
+}
 export function marketMapToHtml(config, set) {
     const model = buildModel(config, set);
     const stateByClaim = new Map(model.fronts.map((front) => [front.claimId, front.state]));
@@ -87,6 +189,8 @@ export function marketMapToHtml(config, set) {
     const unobservable = set.observations.filter((obs) => obs.intensity === "unobservable").length;
     const anchor = config.anchorVendor;
     const e = escapeHtml;
+    const axisHtml = axisSectionsHtml(config, set);
+    const appendixNo = axisHtml.report ? "04" : "03";
     const matrixRows = model.orderedClaimIds
         .map((claimId) => {
         const claim = claimsById.get(claimId);
@@ -184,6 +288,14 @@ tr.front-open th .claim-cap { color:var(--accent); font-weight:600; }
 .ev-head { font-size:10.5px; letter-spacing:.1em; color:var(--accent); }
 .ev blockquote { font-style:italic; margin:6px 0; font-size:13.5px; line-height:1.5; }
 .ev-src { font-size:10px; color:var(--ink-soft); word-break:break-all; }
+figure { margin-top:22px; border:1px solid var(--line); background:rgba(255,255,255,.35); }
+.axis { stroke:var(--ink); stroke-width:1.5; }
+.axis-mid { stroke:var(--line); stroke-dasharray:3 5; }
+.ax-label { letter-spacing:.16em; fill:var(--ink-soft); font-family:"SF Mono",Menlo,Consolas,monospace; }
+.dot { fill:rgba(33,29,22,.78); }
+.dot-anchor { fill:var(--green); stroke:var(--ink); stroke-width:1.5; }
+.dot-label { fill:var(--ink); text-anchor:middle; letter-spacing:.04em; font-family:"SF Mono",Menlo,Consolas,monospace; }
+figcaption { font-size:12px; color:var(--ink-soft); padding:12px 16px 14px; font-style:italic; border-top:1px solid var(--line); line-height:1.5; }
 footer { margin-top:72px; border-top:3px double var(--ink); padding-top:14px; font-size:11px; color:var(--ink-soft);
   display:flex; justify-content:space-between; gap:20px; flex-wrap:wrap; }
 @media print { body { max-width:none; padding:0 8mm; background:white; } section { break-inside:avoid-page; } tr { break-inside:avoid; } }
@@ -221,8 +333,9 @@ footer { margin-top:72px; border-top:3px double var(--ink); padding-top:14px; fo
     <tbody>${matrixRows}</tbody>
   </table>
 </section>
+${axisHtml.strategicMap}
 <section>
-  <h2><span class="no">03</span> Evidence appendix</h2>
+  <h2><span class="no">${appendixNo}</span> Evidence appendix</h2>
   ${appendix}
 </section>
 <footer>