fullstackgtm 0.16.0 → 0.18.0

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/marketClassify.d.ts

@@ -0,0 +1,49 @@
+import { type LlmCallOptions } from "./llm.ts";
+import { type CaptureEntry, type MarketClaim, type MarketConfig, type ObservationSet } from "./market.ts";
+export type ClassifyMarketOptions = {
+    llm: LlmCallOptions;
+    /** Observation run label to produce; must be new (the store is append-only). */
+    runLabel: string;
+    /** Capture run to classify; defaults to the most recent run in the manifest. */
+    captureRun?: string;
+    /** Restrict to these vendor ids (e.g. one new vendor); defaults to all. */
+    vendors?: string[];
+    /** Captures directory override (tests); defaults to the profile market home. */
+    capturesDir?: string;
+    now?: () => Date;
+};
+export type ClassifyMarketResult = {
+    set: ObservationSet;
+    model: string;
+    /** Cells where the model's quote failed mechanical verification and the retry fixed it. */
+    retriedVendorIds: string[];
+};
+export declare function classifyMarket(config: MarketConfig, options: ClassifyMarketOptions): Promise<ClassifyMarketResult>;
+/**
+ * The agent-driven alternative to LLM classification: a worksheet carrying
+ * everything needed to classify one vendor by hand or by an agent driving
+ * the CLI/MCP — claims with judging definitions, the surface rule, and the
+ * captured page texts. Submissions come back through `market observe`,
+ * which runs the same validation and span verification as `classify`.
+ */
+export type MarketWorksheet = {
+    category: string;
+    captureRun: string;
+    surfaceRule?: string;
+    vendor: {
+        id: string;
+        name: string;
+    };
+    claims: MarketClaim[];
+    pages: Array<{
+        kind: CaptureEntry["kind"];
+        url: string;
+        captureHash: string;
+        text: string;
+    }>;
+    instructions: string;
+};
+export declare function buildWorksheet(config: MarketConfig, vendorId: string, options?: {
+    captureRun?: string;
+    capturesDir?: string;
+}): MarketWorksheet;

package/dist/marketClassify.js

@@ -0,0 +1,201 @@
+import { DEFAULT_MODELS, forcedToolCall } from "./llm.js";
+import { loadCaptureTexts, observationId, verifyEvidenceSpans, } from "./market.js";
+/**
+ * LLM intensity classification for the market map — the same
+ * semi-deterministic posture as call extraction, with one upgrade calls
+ * can't have: because the source pages are stored captures, every quoted
+ * span is verified mechanically against the capture it cites before the
+ * observation is accepted. A reading whose quote isn't verbatim on the page
+ * bounces back to the model once with the failures named; if it still can't
+ * quote the page, classification fails rather than storing unverifiable
+ * evidence.
+ *
+ * Deterministic parts stay deterministic: vendors with no usable captures
+ * score UNOBSERVABLE on every claim without an LLM call, and front states
+ * downstream are computed from the store, never from model output.
+ */
+// Bound cost and context: a vendor's pages are classified in one call.
+const MAX_DOSSIER_CHARS = 48_000;
+const CLASSIFY_INSTRUCTIONS = `Classify this vendor's messaging intensity for EVERY claim listed.
+Rules:
+- Judge ONLY from the captured pages below. Do not use outside knowledge of the vendor.
+- intensity per the surface rule: "loud" = hero copy or a top-level-nav named product/program with a dedicated page; "quiet" = present on any page below that; "absent" = nowhere in the captures.
+- evidence quotes MUST be verbatim spans copied exactly from the captured text (≤300 chars). Every loud or quiet reading needs at least one quote. If you cannot quote it, the reading is absent.
+- An explicit disavowal ("we do not offer X", "call 988") is absent — put the disavowal quote in reason, it is informative signal.
+- url must be the page the quote came from, exactly as given in the page headers below.
+- reason: one reviewer-facing sentence.
+- Return a reading for every claim id. Never invent claim ids.`;
+const classifySchema = (claimIds) => ({
+    type: "object",
+    required: ["readings"],
+    properties: {
+        readings: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["claimId", "intensity", "confidence", "reason", "evidence"],
+                properties: {
+                    claimId: { type: "string", enum: claimIds },
+                    intensity: { type: "string", enum: ["loud", "quiet", "absent"] },
+                    confidence: { type: "string", enum: ["high", "medium", "low"] },
+                    reason: { type: "string", description: "One reviewer-facing sentence." },
+                    evidence: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            required: ["quote", "url"],
+                            properties: {
+                                quote: { type: "string", description: "VERBATIM span copied exactly from the captured page text. Never paraphrase." },
+                                url: { type: "string", description: "The page URL the quote came from, exactly as shown in the page header." },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+});
+function buildDossier(entries, textByHash) {
+    const pages = entries
+        .filter((entry) => entry.captureHash && textByHash.has(entry.captureHash))
+        .map((entry) => ({ entry, text: textByHash.get(entry.captureHash) }));
+    if (pages.length === 0)
+        return "";
+    const budget = Math.floor(MAX_DOSSIER_CHARS / pages.length);
+    return pages
+        .map(({ entry, text }) => {
+        const body = text.length <= budget
+            ? text
+            : `${text.slice(0, budget / 2)}\n[... middle of page truncated ...]\n${text.slice(-budget / 2)}`;
+        return `=== PAGE (${entry.kind}) ${entry.url} ===\n${body}`;
+    })
+        .join("\n\n");
+}
+function claimsBlock(claims) {
+    return claims
+        .map((claim) => `- ${claim.id}: ${claim.capability}\n  How to judge: ${claim.definition}`)
+        .join("\n");
+}
+export async function classifyMarket(config, options) {
+    const model = options.llm.model ?? DEFAULT_MODELS[options.llm.provider];
+    const { entries, textByHash } = loadCaptureTexts(config.category, options.capturesDir);
+    if (entries.length === 0) {
+        throw new Error(`No captures for ${config.category} — run \`market capture\` first`);
+    }
+    const captureRun = options.captureRun ?? entries[entries.length - 1].runLabel;
+    const runEntries = entries.filter((entry) => entry.runLabel === captureRun);
+    if (runEntries.length === 0) {
+        throw new Error(`No captures for run "${captureRun}" — available: ${[...new Set(entries.map((e) => e.runLabel))].join(", ")}`);
+    }
+    const observedAt = (options.now ?? (() => new Date()))().toISOString();
+    const vendorIds = options.vendors ?? config.vendors.map((vendor) => vendor.id);
+    const claimIds = config.claims.map((claim) => claim.id);
+    const observations = [];
+    const retriedVendorIds = [];
+    for (const vendorId of vendorIds) {
+        const vendor = config.vendors.find((candidate) => candidate.id === vendorId);
+        if (!vendor)
+            throw new Error(`Unknown vendor "${vendorId}"`);
+        const vendorEntries = runEntries.filter((entry) => entry.vendorId === vendorId);
+        const hashByUrl = new Map(vendorEntries.filter((entry) => entry.captureHash).map((entry) => [entry.url, entry.captureHash]));
+        const dossier = buildDossier(vendorEntries, textByHash);
+        if (!dossier) {
+            // Deterministic: no usable captures means UNOBSERVABLE everywhere — never
+            // ask a model to judge pages that were never read.
+            for (const claim of config.claims) {
+                observations.push({
+                    id: observationId(config.category, options.runLabel, vendorId, claim.id),
+                    vendorId,
+                    claimId: claim.id,
+                    observedAt,
+                    intensity: "unobservable",
+                    confidence: "high",
+                    reason: `No usable captures for ${vendor.name} in run ${captureRun} — cannot judge.`,
+                    evidence: [],
+                });
+            }
+            continue;
+        }
+        const prompt = (feedback) => `${CLASSIFY_INSTRUCTIONS}\n\nSurface rule for this category:\n${config.surfaceRule ?? "(default rule above)"}\n\nClaims to classify (all of them):\n${claimsBlock(config.claims)}\n${feedback}\nVendor: ${vendor.name}\nCaptured pages:\n${dossier}`;
+        const attempt = async (feedback) => {
+            const result = (await forcedToolCall(prompt(feedback), "classify_market_claims", classifySchema(claimIds), model, options.llm));
+            const readings = (result.readings ?? []).filter((reading) => claimIds.includes(reading.claimId));
+            const seen = new Set(readings.map((reading) => reading.claimId));
+            const problems = claimIds.filter((claimId) => !seen.has(claimId)).map((claimId) => `missing reading for ${claimId}`);
+            const candidate = readings.map((reading) => toObservation(reading, vendorId));
+            const failures = verifyEvidenceSpans(candidate, textByHash);
+            return { readings, problems, failures };
+        };
+        const toObservation = (reading, vendor) => ({
+            id: observationId(config.category, options.runLabel, vendor, reading.claimId),
+            vendorId: vendor,
+            claimId: reading.claimId,
+            observedAt,
+            intensity: reading.intensity,
+            confidence: reading.confidence,
+            reason: reading.reason,
+            evidence: (reading.evidence ?? []).map((item, index) => ({
+                id: `${observationId(config.category, options.runLabel, vendor, reading.claimId)}_ev${index}`,
+                sourceSystem: "web",
+                sourceObjectType: "page",
+                sourceObjectId: item.url,
+                text: item.quote,
+                observedAt,
+                metadata: { url: item.url, captureHash: hashByUrl.get(item.url) ?? "" },
+            })),
+        });
+        let outcome = await attempt("");
+        if (outcome.problems.length > 0 || outcome.failures.length > 0) {
+            retriedVendorIds.push(vendorId);
+            const failureLines = [
+                ...outcome.problems,
+                ...outcome.failures.map((failure) => `${failure.claimId}: ${failure.problem} (your quote: "${failure.quote.slice(0, 80)}")`),
+            ].join("\n- ");
+            outcome = await attempt(`\nYour previous answer had problems. Fix exactly these and answer again in full:\n- ${failureLines}\nQuotes must be copied character-for-character from the captured text.\n`);
+        }
+        if (outcome.problems.length > 0 || outcome.failures.length > 0) {
+            const detail = [...outcome.problems, ...outcome.failures.map((failure) => `${failure.claimId}: ${failure.problem}`)].slice(0, 10);
+            throw new Error(`Classification for ${vendor.name} failed mechanical verification after a retry:\n  ${detail.join("\n  ")}\nNothing was stored. Re-run, try another --model, or classify this vendor by hand via the worksheet.`);
+        }
+        for (const reading of outcome.readings)
+            observations.push(toObservation(reading, vendorId));
+    }
+    return {
+        set: {
+            id: `set_${config.category}_${options.runLabel}`,
+            category: config.category,
+            runLabel: options.runLabel,
+            runAt: observedAt,
+            extractor: `llm:${options.llm.provider}:${model}`,
+            observations,
+        },
+        model,
+        retriedVendorIds,
+    };
+}
+export function buildWorksheet(config, vendorId, options = {}) {
+    const vendor = config.vendors.find((candidate) => candidate.id === vendorId);
+    if (!vendor)
+        throw new Error(`Unknown vendor "${vendorId}"`);
+    const { entries, textByHash } = loadCaptureTexts(config.category, options.capturesDir);
+    const captureRun = options.captureRun ?? entries[entries.length - 1]?.runLabel;
+    if (!captureRun)
+        throw new Error(`No captures for ${config.category} — run \`market capture\` first`);
+    const pages = entries
+        .filter((entry) => entry.runLabel === captureRun && entry.vendorId === vendorId && entry.captureHash)
+        .map((entry) => ({
+        kind: entry.kind,
+        url: entry.url,
+        captureHash: entry.captureHash,
+        text: textByHash.get(entry.captureHash) ?? "",
+    }));
+    return {
+        category: config.category,
+        captureRun,
+        surfaceRule: config.surfaceRule,
+        vendor: { id: vendor.id, name: vendor.name },
+        claims: config.claims,
+        pages,
+        instructions: "Produce one observation per claim (intensity loud|quiet|absent from these pages only; unobservable only if a page you need failed to capture). Every loud/quiet reading must quote a verbatim span (≤300 chars) from a page's text, with that page's url and captureHash in evidence metadata. Submit as an ObservationSet via `market observe --from <file>` — quotes are mechanically verified against the captures.",
+    };
+}

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>

package/dist/mcp.js

@@ -47,6 +47,8 @@ import { builtinAuditRules } from "./rules.js";
 import { sampleSnapshot } from "./sampleData.js";
 import { normalizeTranscript, parseCall } from "./calls.js";
 import { extractInsightsLlm, resolveLlmCredential } from "./llm.js";
+import { computeFrontStates, createFileObservationStore, loadCaptureTexts, loadMarketConfig, validateObservationSet, verifyEvidenceSpans, } from "./market.js";
+import { buildWorksheet } from "./marketClassify.js";
 import { resolveRecord } from "./resolve.js";
 import { suggestValues } from "./suggest.js";
 function content(value) {
@@ -244,6 +246,49 @@ export async function startMcpServer() {
         });
         return content(output === "markdown" ? formatPatchPlanRun(run) : run);
     });
+    server.registerTool("fullstackgtm_market_worksheet", {
+        title: "Market Map Classification Worksheet",
+        description: "Get everything needed to classify ONE vendor's messaging intensity for a market map: " +
+            "the claim taxonomy with judging definitions, the surface rule, and the captured page " +
+            "texts. Read each claim's definition, judge loud/quiet/absent from the page texts only, " +
+            "and quote verbatim spans (≤300 chars) for every loud/quiet reading. Submit the full " +
+            "ObservationSet via fullstackgtm_market_observe — quotes are verified character-for-" +
+            "character against the captures, so never paraphrase.",
+        inputSchema: {
+            vendorId: z.string(),
+            configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
+            captureRun: z.string().optional(),
+        },
+    }, async ({ vendorId, configPath, captureRun }) => {
+        const config = loadMarketConfig(resolve(process.cwd(), configPath ?? "market.config.json"));
+        return content(buildWorksheet(config, vendorId, { captureRun }));
+    });
+    server.registerTool("fullstackgtm_market_observe", {
+        title: "Submit Market Map Observations",
+        description: "Submit a complete ObservationSet (every vendor × claim cell) for a market map run. " +
+            "Validates coverage, the verbatim-evidence rule, and mechanically verifies every quoted " +
+            "span against the stored capture it cites. Returns problems if rejected; nothing is " +
+            "stored unless the whole set passes. Observations are append-only — use a new runLabel.",
+        inputSchema: {
+            observationsPath: z.string().describe("Path to the ObservationSet JSON file"),
+            configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
+        },
+    }, async ({ observationsPath, configPath }) => {
+        const config = loadMarketConfig(resolve(process.cwd(), configPath ?? "market.config.json"));
+        const set = JSON.parse(readFileSync(resolve(process.cwd(), observationsPath), "utf8"));
+        const problems = validateObservationSet(config, set);
+        const failures = verifyEvidenceSpans(set.observations, loadCaptureTexts(config.category).textByHash);
+        if (problems.length > 0 || failures.length > 0) {
+            return content({
+                accepted: false,
+                problems,
+                spanFailures: failures.map((failure) => `${failure.vendorId} × ${failure.claimId}: ${failure.problem}`),
+            });
+        }
+        await createFileObservationStore(config.category).append(set);
+        const fronts = computeFrontStates(config, set);
+        return content({ accepted: true, runLabel: set.runLabel, observations: set.observations.length, fronts });
+    });
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }