fullstackgtm 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -5,6 +5,75 @@ 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
+the verbatim-quote rule becomes a mechanical gate instead of a prompt
+instruction.
+
+### Added
+
+- **`fullstackgtm market classify`** — LLM intensity readings for every
+  vendor × claim cell from the stored captures, through the same
+  bring-your-own-key constrained-tool-call seam as `call parse`
+  (provenance `extractor: "llm:<provider>:<model>"`). Vendors with no
+  usable captures score UNOBSERVABLE deterministically, without an LLM
+  call. `--vendor` classifies one vendor to `--out` for hand-merging;
+  `--model` overrides the provider default.
+- **Mechanical span verification** — because market sources are *stored*
+  captures (unlike transcripts, which pass through), every quoted evidence
+  span is checked character-for-character (whitespace-normalized) against
+  the capture it cites. Readings that fail bounce back to the model once
+  with the failures named; persistent failures abort with nothing stored.
+  The same gate now guards `market observe` (escape hatch: `--unverified`,
+  for sets whose captures genuinely live elsewhere) and the MCP submission
+  path — every proposal channel passes the same gate.
+- **`fullstackgtm market worksheet --vendor <id>`** — the no-key channel:
+  a self-contained packet (claims with judging definitions, surface rule,
+  captured page texts) for an agent or human to classify by hand and
+  submit via `observe`.
+- **`fullstackgtm market refresh`** — capture → classify → front drift →
+  HTML field report, one command. The weekly refresh is now a single
+  invocation (schedule it however you schedule things).
+- **MCP**: `fullstackgtm_market_worksheet` and `fullstackgtm_market_observe`
+  (validates + verifies + appends; returns the computed front states on
+  acceptance).
+- `forcedToolCall` exported from `llm.ts` — the one seam every LLM feature
+  in the package goes through.
+
 ## [0.16.0] — 2026-06-11
 
 The market map: a live model of the competitive category a company sells

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

@@ -18,7 +18,9 @@ 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 { 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";
 import { resolveRecord } from "./resolve.js";
@@ -59,13 +61,19 @@ Usage:
                                                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 classify [--run <label>] [--vendor <id>] [--model m] [--out <path>]
+  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),
-                                               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
+                                               classify intensity per claim (LLM bring-your-own-key, or fill the
+                                               worksheet with any agent) — every quoted span is verified verbatim
+                                               against the stored capture it cites before it's accepted — then
+                                               compute deterministic front states and drift, render the field
+                                               report. refresh = capture → classify → drift → report in one step
   fullstackgtm suggest --plan-id <id> | --plan <path>  [source options] [--json] [--out <path>]
                                                derive values for requires_human_* placeholders
                                                from snapshot evidence, with confidence + reasons
@@ -617,9 +625,14 @@ async function requireLlmCredential(command = "parse") {
     if (resolved)
         return resolved;
     // Scoring is inherently LLM work — there is no keyword fallback to suggest.
-    const fallbackHint = command === "parse" ? ", or pass --deterministic for the free keyword baseline" : " (call score has no non-LLM mode)";
+    const fallbackHint = command === "parse"
+        ? ", or pass --deterministic for the free keyword baseline"
+        : command === "score"
+            ? " (call score has no non-LLM mode)"
+            : ", or classify by hand: `market worksheet --vendor <id>` then `market observe --from`";
+    const work = command === "score" ? "scoring" : command === "parse" ? "extraction" : "classification";
     if (!process.stdin.isTTY) {
-        throw new Error(`LLM ${command === "score" ? "scoring" : "extraction"} needs an API key. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run \`echo "$KEY" | fullstackgtm login anthropic\` (or \`login openai\`) once${fallbackHint}.`);
+        throw new Error(`LLM ${work} needs an API key. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run \`echo "$KEY" | fullstackgtm login anthropic\` (or \`login openai\`) once${fallbackHint}.`);
     }
     console.error("LLM parsing needs an API key (Anthropic or OpenAI) — yours, used directly with the provider.");
     console.error(`Paste it once; it is validated and stored at ${credentialsPath()} (file mode 0600), like CRM logins.`);
@@ -729,9 +742,11 @@ function buildCallPlan(parsed, deal, proposed, current, extraNextSteps) {
 /**
  * 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.
+ * states and reports computed from the store. Intensity readings enter as
+ * proposals through two channels — `classify` (LLM, bring-your-own-key, the
+ * call-intelligence pattern) and `worksheet`/`observe` (an agent or human
+ * fills the worksheet) — and BOTH pass the same mechanical gate: every quoted
+ * span is verified verbatim against the stored capture it cites.
  */
 async function marketCommand(args) {
     const [subcommand, ...rest] = args;
@@ -740,9 +755,26 @@ async function marketCommand(args) {
         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 classify [--run <label>] [--capture-run <label>] [--vendor <id>] [--model m] [--out <path>]
+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
+is verified character-for-character against the capture it cites before the
+observation is accepted — quotes that aren't on the page bounce.
 
 The taxonomy (vendors + claims) is config you review and version; captures
 and observations live under ~/.fullstackgtm/market/<category> (profile-scoped,
@@ -785,10 +817,97 @@ recomputed deterministically on every invocation — never stored.`);
             process.exitCode = 1;
             return;
         }
+        if (!rest.includes("--unverified")) {
+            const { textByHash } = loadCaptureTexts(config.category);
+            const failures = verifyEvidenceSpans(set.observations, textByHash);
+            if (failures.length > 0) {
+                console.error(`Rejected: ${failures.length} evidence span(s) failed verification against the stored captures`);
+                for (const failure of failures.slice(0, 20)) {
+                    console.error(`  - ${failure.vendorId} × ${failure.claimId}: ${failure.problem}`);
+                }
+                console.error("Quotes must be copied verbatim from the captured pages. (--unverified skips this gate when the captures genuinely live elsewhere.)");
+                process.exitCode = 1;
+                return;
+            }
+        }
         await store.append(set);
         console.log(`Appended ${set.runLabel}: ${set.observations.length} observations (${set.extractor})`);
         return;
     }
+    if (subcommand === "worksheet") {
+        const vendorId = option(rest, "--vendor");
+        if (!vendorId)
+            throw new Error("market worksheet requires --vendor <id>");
+        const worksheet = buildWorksheet(config, vendorId, { captureRun: option(rest, "--capture-run") ?? undefined });
+        const outPath = option(rest, "--out");
+        const payload = `${JSON.stringify(worksheet, null, 2)}\n`;
+        if (outPath) {
+            writeFileSync(resolve(process.cwd(), outPath), payload);
+            console.log(`Wrote ${outPath} (${worksheet.pages.length} captured pages, ${worksheet.claims.length} claims)`);
+        }
+        else {
+            console.log(payload);
+        }
+        return;
+    }
+    if (subcommand === "classify") {
+        const credential = await requireLlmCredential("market classify");
+        const vendorFilter = option(rest, "--vendor");
+        const outPath = option(rest, "--out");
+        if (vendorFilter && !outPath) {
+            throw new Error("market classify --vendor produces a partial set (coverage validation would reject it) — pass --out <path> to inspect/merge it by hand");
+        }
+        const result = await classifyMarket(config, {
+            llm: { ...credential, model: option(rest, "--model") ?? undefined },
+            runLabel: option(rest, "--run") ?? option(rest, "--capture-run") ?? "run-1",
+            captureRun: option(rest, "--capture-run") ?? undefined,
+            vendors: vendorFilter ? [vendorFilter] : undefined,
+        });
+        if (result.retriedVendorIds.length > 0) {
+            console.error(`Span verification bounced ${result.retriedVendorIds.join(", ")} once; retry passed.`);
+        }
+        if (outPath) {
+            writeFileSync(resolve(process.cwd(), outPath), `${JSON.stringify(result.set, null, 2)}\n`);
+            console.log(`Wrote ${outPath}: ${result.set.observations.length} verified observations (${result.set.extractor})`);
+            return;
+        }
+        const problems = validateObservationSet(config, result.set);
+        if (problems.length > 0) {
+            throw new Error(`Classified set failed validation: ${problems.slice(0, 5).join("; ")}`);
+        }
+        await store.append(result.set);
+        console.log(`Appended ${result.set.runLabel}: ${result.set.observations.length} observations, every span verified (${result.set.extractor})`);
+        return;
+    }
+    if (subcommand === "refresh") {
+        const credential = await requireLlmCredential("market classify");
+        const runLabel = option(rest, "--run") ?? `run-${new Date().toISOString().slice(0, 10)}`;
+        const prior = await store.latest();
+        console.log(`Capturing ${config.vendors.length} vendors as ${runLabel}…`);
+        const captured = await captureMarket(config, { runLabel });
+        const failed = captured.entries.filter((entry) => !entry.captureHash);
+        if (failed.length > 0)
+            console.log(`${failed.length} page(s) failed/empty — affected cells will verify against remaining pages or read unobservable.`);
+        console.log(`Classifying with ${credential.provider}…`);
+        const result = await classifyMarket(config, {
+            llm: { ...credential, model: option(rest, "--model") ?? undefined },
+            runLabel,
+            captureRun: runLabel,
+        });
+        await store.append(result.set);
+        const fronts = computeFrontStates(config, result.set);
+        if (prior) {
+            const drift = diffFrontStates(computeFrontStates(config, prior), fronts);
+            if (drift.length === 0)
+                console.log(`No front changes since ${prior.runLabel}.`);
+            for (const change of drift)
+                console.log(`CHANGED   ${change.claimId}: ${change.before} → ${change.after}`);
+        }
+        const outPath = option(rest, "--out") ?? `${config.category}-${runLabel}.html`;
+        writeFileSync(resolve(process.cwd(), outPath), marketMapToHtml(config, result.set));
+        console.log(`Wrote ${outPath}`);
+        return;
+    }
     const loadSet = async () => {
         const runLabel = option(rest, "--run");
         const set = runLabel ? await store.get(runLabel) : await store.latest();
@@ -838,7 +957,17 @@ recomputed deterministically on every invocation — never stored.`);
         }
         return;
     }
-    throw new Error(`Unknown market subcommand: ${subcommand} (try: init, capture, observe, fronts, report)`);
+    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,9 @@ 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 { 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";
 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,6 +19,8 @@ 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 { 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/llm.d.ts

@@ -64,6 +64,13 @@ export declare function scoreCallLlm(transcript: string, rubric: Rubric, options
     title?: string;
 }): Promise<CallScorecard>;
 export declare function parseRubric(json: string): Rubric;
+/**
+ * Shared constrained-tool-call plumbing: force the model to answer through a
+ * single tool whose input_schema is the output contract. Exported for other
+ * semi-deterministic features (market classification) — every LLM feature in
+ * the package goes through this one seam.
+ */
+export declare function forcedToolCall(prompt: string, toolName: string, schema: object, model: string, options: LlmCallOptions): Promise<unknown>;
 /** Cheap key validation against the provider's model-list endpoint. Status line only. */
 export declare function validateLlmKey(provider: LlmProvider, apiKey: string, fetchImpl?: typeof fetch): Promise<{
     ok: boolean;

package/dist/llm.js

@@ -158,7 +158,13 @@ export function parseRubric(json) {
     };
 }
 // ── Provider plumbing (raw fetch, forced tool calls) ───────────────────────
-async function forcedToolCall(prompt, toolName, schema, model, options) {
+/**
+ * Shared constrained-tool-call plumbing: force the model to answer through a
+ * single tool whose input_schema is the output contract. Exported for other
+ * semi-deterministic features (market classification) — every LLM feature in
+ * the package goes through this one seam.
+ */
+export async function forcedToolCall(prompt, toolName, schema, model, options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     if (options.provider === "anthropic") {
         const response = await llmFetch(fetchImpl, ANTHROPIC_URL, {

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. */
@@ -126,6 +142,25 @@ export declare function createFileObservationStore(category: string, directory?:
  * Returns problems; an empty array means accept.
  */
 export declare function validateObservationSet(config: MarketConfig, set: ObservationSet): string[];
+export declare function loadCaptureTexts(category: string, directory?: string): {
+    entries: CaptureEntry[];
+    textByHash: Map<string, string>;
+};
+/**
+ * Whitespace-only normalization for span matching, plus one extraction
+ * artifact: the HTML-to-text step can emit a line break before punctuation
+ * that follows an inline tag ("placements\n. Districts"), which no honest
+ * quoter would reproduce — so whitespace *before* punctuation is dropped
+ * too. Words, casing, and characters must still match the page exactly.
+ */
+export declare function normalizeForMatch(value: string): string;
+export type SpanVerificationFailure = {
+    vendorId: string;
+    claimId: string;
+    quote: string;
+    problem: string;
+};
+export declare function verifyEvidenceSpans(observations: MarketObservation[], textByHash: Map<string, string>): SpanVerificationFailure[];
 export type ClaimFront = {
     claimId: string;
     state: FrontState;

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) {
@@ -270,6 +294,82 @@ export function validateObservationSet(config, set) {
     }
     return problems;
 }
+// ---------------------------------------------------------------------------
+// Evidence span verification — the deterministic gate that makes the
+// verbatim-quote rule mechanical instead of a prompt instruction. Because the
+// source documents are *stored* (unlike call transcripts, which pass through),
+// every quoted span can be checked against the capture it cites before the
+// observation is accepted. Comparison is whitespace-normalized only: case and
+// wording must match the page exactly.
+export function loadCaptureTexts(category, directory) {
+    const dir = directory ?? join(marketHome(category), "captures");
+    const manifestPath = join(dir, "manifest.json");
+    const entries = existsSync(manifestPath)
+        ? JSON.parse(readFileSync(manifestPath, "utf8"))
+        : [];
+    const textByHash = new Map();
+    for (const entry of entries) {
+        if (entry.captureHash && !textByHash.has(entry.captureHash)) {
+            try {
+                textByHash.set(entry.captureHash, readFileSync(join(dir, `${entry.captureHash}.txt`), "utf8"));
+            }
+            catch {
+                // Missing capture file: verification of anything citing it will fail loudly.
+            }
+        }
+    }
+    return { entries, textByHash };
+}
+/**
+ * Whitespace-only normalization for span matching, plus one extraction
+ * artifact: the HTML-to-text step can emit a line break before punctuation
+ * that follows an inline tag ("placements\n. Districts"), which no honest
+ * quoter would reproduce — so whitespace *before* punctuation is dropped
+ * too. Words, casing, and characters must still match the page exactly.
+ */
+export function normalizeForMatch(value) {
+    return value
+        .replace(/\s+([.,;:!?])/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function verifyEvidenceSpans(observations, textByHash) {
+    const failures = [];
+    for (const obs of observations) {
+        for (const evidence of obs.evidence) {
+            const quote = evidence.text ?? "";
+            const hash = String(evidence.metadata?.captureHash ?? "");
+            if (!hash) {
+                failures.push({
+                    vendorId: obs.vendorId,
+                    claimId: obs.claimId,
+                    quote,
+                    problem: "evidence has no captureHash — spans must cite a stored capture",
+                });
+                continue;
+            }
+            const captureText = textByHash.get(hash);
+            if (captureText === undefined) {
+                failures.push({
+                    vendorId: obs.vendorId,
+                    claimId: obs.claimId,
+                    quote,
+                    problem: `capture ${hash.slice(0, 12)} not found — evidence must stay resolvable`,
+                });
+                continue;
+            }
+            if (!normalizeForMatch(captureText).includes(normalizeForMatch(quote))) {
+                failures.push({
+                    vendorId: obs.vendorId,
+                    claimId: obs.claimId,
+                    quote,
+                    problem: `quote not found verbatim in capture ${hash.slice(0, 12)}`,
+                });
+            }
+        }
+    }
+    return failures;
+}
 /**
  * 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

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;