fullstackgtm 0.15.0 → 0.17.0

package/dist/market.js

@@ -0,0 +1,395 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { credentialsDir } from "./credentials.js";
+const INTENSITY_RANK = {
+    loud: 3,
+    quiet: 2,
+    absent: 1,
+    unobservable: 0,
+};
+// Mirrors stableHash in rules.ts (FNV-1a); duplicated to keep market.ts
+// importable without pulling the audit engine.
+function fnv1a(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+export function observationId(category, runLabel, vendorId, claimId) {
+    return `obs_${fnv1a(`${category}|${runLabel}|${vendorId}|${claimId}`)}`;
+}
+// ---------------------------------------------------------------------------
+// Config
+export function parseMarketConfig(raw) {
+    const config = JSON.parse(raw);
+    if (!config.category)
+        throw new Error("market config: missing category");
+    if (!Array.isArray(config.vendors) || config.vendors.length === 0) {
+        throw new Error("market config: at least one vendor is required");
+    }
+    if (!Array.isArray(config.claims) || config.claims.length === 0) {
+        throw new Error("market config: at least one claim is required");
+    }
+    for (const [label, items] of [
+        ["vendor", config.vendors],
+        ["claim", config.claims],
+    ]) {
+        const seen = new Set();
+        for (const item of items) {
+            if (!item.id)
+                throw new Error(`market config: ${label} missing id`);
+            if (seen.has(item.id))
+                throw new Error(`market config: duplicate ${label} id "${item.id}"`);
+            seen.add(item.id);
+        }
+    }
+    if (config.anchorVendor && !config.vendors.some((v) => v.id === config.anchorVendor)) {
+        throw new Error(`market config: anchorVendor "${config.anchorVendor}" is not in vendors`);
+    }
+    return config;
+}
+export function loadMarketConfig(path) {
+    return parseMarketConfig(readFileSync(path, "utf8"));
+}
+export function starterMarketConfig(category) {
+    return {
+        category,
+        anchorVendor: "your-company",
+        vendors: [
+            {
+                id: "your-company",
+                name: "Your Company",
+                urls: { home: "https://example.com/", pricing: null, product: [] },
+                notes: "Replace with the real vendor set (≤10 works well). pricing: null records 'no public pricing page'.",
+            },
+        ],
+        claims: [
+            {
+                id: "example-claim",
+                capability: "Example capability: what is being claimed, stated precisely",
+                icp: "who-buys-it",
+                pricingStructure: "how-it-is-priced",
+                definition: "LOUD if the claim is hero copy or a top-nav named product with a dedicated page; QUIET if it appears only on pages below that; ABSENT if nowhere. Write the definition so a human could judge any vendor's page against it.",
+            },
+        ],
+        surfaceRule: "LOUD = hero copy OR top-level-nav named product with dedicated page; QUIET = present on any indexed page below that; ABSENT = nowhere observed (explicit disavowals score ABSENT with the disavowal quoted in reason); UNOBSERVABLE = capture empty/failed — never score ABSENT from a failed capture.",
+    };
+}
+// ---------------------------------------------------------------------------
+// Profile-scoped market home: captures and observations live with credentials
+// so --profile isolation covers category intel too.
+export function marketHome(category, baseDir) {
+    return join(baseDir ?? credentialsDir(), "market", category);
+}
+// ---------------------------------------------------------------------------
+// Capture: fetch vendor pages, strip to readable text, store content-addressed.
+// The hash cache is the change detector (unchanged page = same hash = no new
+// classification needed), the replay buffer (re-judge a revised taxonomy
+// without re-scraping), and the evidence chain (quoted spans stay resolvable).
+const STRIP_BLOCKS = /<(script|style|noscript|svg|head)\b[\s\S]*?<\/\1\s*>/gi;
+const ENTITIES = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&mdash;": "—",
+    "&ndash;": "–",
+};
+export function extractReadableText(html) {
+    const withoutBlocks = html.replace(STRIP_BLOCKS, " ");
+    const withBreaks = withoutBlocks.replace(/<(\/p|\/div|\/li|\/h[1-6]|br\s*\/?)>/gi, "\n");
+    const withoutTags = withBreaks.replace(/<[^>]+>/g, " ");
+    const decoded = withoutTags
+        .replace(/&[a-z#0-9]+;/gi, (entity) => ENTITIES[entity.toLowerCase()] ?? " ")
+        .replace(/[ \t]+/g, " ");
+    return decoded
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+const defaultFetchPage = async (url) => {
+    const response = await fetch(url, {
+        headers: {
+            "User-Agent": "fullstackgtm-market/0 (+https://github.com/fullstackgtm/core)",
+            "Accept-Language": "en-US",
+        },
+        redirect: "follow",
+    });
+    return { status: response.status, body: await response.text() };
+};
+export async function captureMarket(config, options = {}) {
+    const dir = options.dir ?? join(marketHome(config.category), "captures");
+    const runLabel = options.runLabel ?? "run-1";
+    const fetchPage = options.fetchPage ?? defaultFetchPage;
+    const fetchedAt = (options.now ?? (() => new Date()))().toISOString();
+    mkdirSync(dir, { recursive: true });
+    const manifestPath = join(dir, "manifest.json");
+    const manifest = existsSync(manifestPath)
+        ? JSON.parse(readFileSync(manifestPath, "utf8"))
+        : [];
+    const entries = [];
+    for (const vendor of config.vendors) {
+        const targets = [
+            { kind: "home", url: vendor.urls.home },
+        ];
+        if (vendor.urls.pricing)
+            targets.push({ kind: "pricing", url: vendor.urls.pricing });
+        for (const url of vendor.urls.product)
+            targets.push({ kind: "product", url });
+        for (const target of targets) {
+            let status = null;
+            let text = "";
+            try {
+                const page = await fetchPage(target.url);
+                status = page.status;
+                if (page.status === 200)
+                    text = extractReadableText(page.body);
+            }
+            catch {
+                status = null;
+            }
+            let captureHash = null;
+            if (text) {
+                captureHash = createHash("sha256").update(text).digest("hex");
+                // Content-addressed: an unchanged page dedupes to the same file.
+                writeFileSync(join(dir, `${captureHash}.txt`), text);
+            }
+            const entry = {
+                runLabel,
+                vendorId: vendor.id,
+                kind: target.kind,
+                url: target.url,
+                fetchedAt,
+                httpStatus: status,
+                captureHash,
+                textChars: text.length,
+            };
+            manifest.push(entry);
+            entries.push(entry);
+        }
+    }
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return { entries, manifestPath };
+}
+export function createFileObservationStore(category, directory) {
+    const dir = directory ?? join(marketHome(category), "observations");
+    function fileFor(runLabel) {
+        if (!/^[\w.-]+$/.test(runLabel))
+            throw new Error(`Invalid run label: ${runLabel}`);
+        return join(dir, `${runLabel}.json`);
+    }
+    function read(runLabel) {
+        try {
+            return JSON.parse(readFileSync(fileFor(runLabel), "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    function listSets() {
+        let names = [];
+        try {
+            names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+        }
+        catch {
+            return [];
+        }
+        return names
+            .map((name) => read(name.replace(/\.json$/, "")))
+            .filter((set) => set !== null)
+            .sort((a, b) => a.runAt.localeCompare(b.runAt));
+    }
+    return {
+        async append(set) {
+            if (set.category !== category) {
+                throw new Error(`Observation set category "${set.category}" does not match store "${category}"`);
+            }
+            if (read(set.runLabel)) {
+                throw new Error(`Run "${set.runLabel}" already exists — observations are append-only; use a new run label`);
+            }
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(fileFor(set.runLabel), `${JSON.stringify(set, null, 2)}\n`);
+            return set;
+        },
+        async get(runLabel) {
+            return read(runLabel);
+        },
+        async list() {
+            return listSets().map((set) => ({
+                runLabel: set.runLabel,
+                runAt: set.runAt,
+                observations: set.observations.length,
+            }));
+        },
+        async latest() {
+            const sets = listSets();
+            return sets.length ? sets[sets.length - 1] : null;
+        },
+    };
+}
+/**
+ * Validate a proposed observation set against the config before it enters
+ * the store: known vendors/claims, full coverage, legal readings, and the
+ * verbatim-evidence rule (non-absent readings must quote something).
+ * Returns problems; an empty array means accept.
+ */
+export function validateObservationSet(config, set) {
+    const problems = [];
+    const vendorIds = new Set(config.vendors.map((v) => v.id));
+    const claimIds = new Set(config.claims.map((c) => c.id));
+    const seen = new Set();
+    for (const obs of set.observations) {
+        const cell = `${obs.vendorId} × ${obs.claimId}`;
+        if (!vendorIds.has(obs.vendorId))
+            problems.push(`unknown vendor "${obs.vendorId}"`);
+        if (!claimIds.has(obs.claimId))
+            problems.push(`unknown claim "${obs.claimId}"`);
+        if (seen.has(cell))
+            problems.push(`duplicate observation for ${cell}`);
+        seen.add(cell);
+        if (!INTENSITY_RANK[obs.intensity] && obs.intensity !== "unobservable") {
+            problems.push(`${cell}: invalid intensity "${obs.intensity}"`);
+        }
+        if ((obs.intensity === "loud" || obs.intensity === "quiet") && obs.evidence.length === 0) {
+            problems.push(`${cell}: ${obs.intensity} reading with no quoted evidence`);
+        }
+    }
+    for (const vendor of config.vendors) {
+        for (const claim of config.claims) {
+            if (!seen.has(`${vendor.id} × ${claim.id}`)) {
+                problems.push(`missing observation for ${vendor.id} × ${claim.id}`);
+            }
+        }
+    }
+    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
+ * excluded — a failed capture never reads as absence.
+ */
+export function computeFrontStates(config, set) {
+    const byCell = new Map();
+    for (const obs of set.observations) {
+        const key = `${obs.vendorId}|${obs.claimId}`;
+        const existing = byCell.get(key);
+        if (!existing || INTENSITY_RANK[obs.intensity] > INTENSITY_RANK[existing.intensity]) {
+            byCell.set(key, obs);
+        }
+    }
+    return config.claims.map((claim) => {
+        const loud = [];
+        const quiet = [];
+        for (const vendor of config.vendors) {
+            const obs = byCell.get(`${vendor.id}|${claim.id}`);
+            if (obs?.intensity === "loud")
+                loud.push(vendor.id);
+            if (obs?.intensity === "quiet")
+                quiet.push(vendor.id);
+        }
+        let state;
+        if (loud.length === 0)
+            state = quiet.length >= 1 ? "open" : "vacant";
+        else if (loud.length === 1)
+            state = "owned";
+        else if (loud.length <= 3)
+            state = "contested";
+        else
+            state = "saturated";
+        return { claimId: claim.id, state, loudVendorIds: loud, quietVendorIds: quiet };
+    });
+}
+/** What changed in the category between two runs — the refresh's whole point. */
+export function diffFrontStates(before, after) {
+    const prior = new Map(before.map((front) => [front.claimId, front.state]));
+    const drift = [];
+    for (const front of after) {
+        const was = prior.get(front.claimId);
+        if (was && was !== front.state)
+            drift.push({ claimId: front.claimId, before: was, after: front.state });
+    }
+    return drift;
+}

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

@@ -0,0 +1,3 @@
+import type { MarketConfig, ObservationSet } from "./market.ts";
+export declare function marketMapToMarkdown(config: MarketConfig, set: ObservationSet): string;
+export declare function marketMapToHtml(config: MarketConfig, set: ObservationSet): string;