webrecipe 0.1.0

package/dist/src/authoring/candidates.js

@@ -0,0 +1,168 @@
+import { parseHtmlFragment } from '../executor/extract.js';
+const SAMPLE_COUNT = 3;
+/** How far up the tree an address may walk before the chain gets too brittle to trust. */
+const ADDRESS_DEPTH = 8;
+/** Text these carry is code, not content, and it would dominate the ranking. */
+const NOISE = 'script, style, noscript, template';
+/**
+ * The document every part of this harness works on. The generator and the
+ * scorer have to agree on what is on the page: scored against a document that
+ * still holds its `<template>` contents, a correct selector reads as
+ * over-matching and a wrong one can read as exact.
+ */
+export function loadPage(html) {
+    const $ = parseHtmlFragment(html);
+    $(NOISE).remove();
+    return $;
+}
+function nodesOf($, selector) { return $(selector).toArray(); }
+export const isEl = (n) => 'tagName' in n;
+export function elementsOf($, selector) {
+    return nodesOf($, selector).filter(isEl);
+}
+export const normalize = (value) => value.replace(/\s+/g, ' ').trim();
+/**
+ * Everything this element says: its rendered text, and the alternative text of
+ * any image it holds. A shelf of books says nothing in text at all — each item
+ * is a cover, and the title is the cover's `alt` — so a definition that stops
+ * at `.text()` cannot tell one item from another. The generator, the label
+ * dump and the scorer all read the page through this, for the same reason they
+ * all parse it through `loadPage`.
+ */
+export function perceivedText($, el) {
+    const own = el.tagName.toLowerCase() === 'img' ? $(el).attr('alt') ?? '' : '';
+    const alts = $(el).find('img[alt]').map((_, img) => $(img).attr('alt') ?? '').toArray();
+    return normalize([own, $(el).text(), ...alts].join(' '));
+}
+const textOf = perceivedText;
+/** A class like Tailwind's `md:flex` is not a bare CSS identifier; escape it. */
+export function escapeIdent(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, (ch) => `\\${ch}`);
+}
+export function signatureOf($, el) {
+    const classes = ($(el).attr('class') ?? '').trim().split(/\s+/).filter(Boolean);
+    return el.tagName.toLowerCase() + classes.map((c) => `.${escapeIdent(c)}`).join('');
+}
+/**
+ * The shortest selector that addresses this one element, or null when eight
+ * ancestors were not enough to find one. Uniqueness is checked by running each
+ * form rather than assumed, because an escaped class or an unusual document can
+ * make a plausible-looking address match something else.
+ */
+function addressOf($, el, depth = ADDRESS_DEPTH, memo = new Map()) {
+    // Groups under one parent share that parent, and parents share ancestors: on a
+    // 10k-element page the same address was recomputed, whole-document query and
+    // all, hundreds of times.
+    const known = memo.get(el)?.get(depth);
+    if (known !== undefined)
+        return known;
+    const address = uncachedAddressOf($, el, depth, memo);
+    if (!memo.has(el))
+        memo.set(el, new Map());
+    memo.get(el).set(depth, address);
+    return address;
+}
+function uncachedAddressOf($, el, depth, memo) {
+    if (depth === 0)
+        return null;
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'body' || tag === 'html')
+        return tag;
+    const id = $(el).attr('id');
+    if (id !== undefined && id !== '') {
+        const byId = `#${escapeIdent(id)}`;
+        if (elementsOf($, byId).length === 1)
+            return byId;
+    }
+    const own = signatureOf($, el);
+    if (elementsOf($, own).length === 1)
+        return own;
+    const parent = el.parent;
+    if (parent === null || !isEl(parent))
+        return null;
+    const parentAddress = addressOf($, parent, depth - 1, memo);
+    if (parentAddress === null)
+        return null;
+    const nth = $(el).prevAll(tag).length + 1;
+    const chained = `${parentAddress} > ${tag}:nth-of-type(${nth})`;
+    return elementsOf($, chained).length === 1 ? chained : null;
+}
+function groupsOf($) {
+    const groups = [];
+    for (const parent of elementsOf($, '*')) {
+        const bySignature = new Map();
+        for (const child of $(parent).children().toArray().filter(isEl)) {
+            const signature = signatureOf($, child);
+            const run = bySignature.get(signature);
+            if (run)
+                run.push(child);
+            else
+                bySignature.set(signature, [child]);
+        }
+        for (const [signature, elements] of bySignature) {
+            if (elements.length >= 2)
+                groups.push({ parent, signature, elements });
+        }
+    }
+    return groups;
+}
+/** Materialises a proposed selector: what it matches is what gets reported. */
+function materialize($, selector, scoped) {
+    const matched = elementsOf($, selector);
+    if (matched.length < 2)
+        return null;
+    if (matched.every((el) => textOf($, el) === ''))
+        return null;
+    const samples = matched.slice(0, SAMPLE_COUNT).map((el) => textOf($, el));
+    return { selector, count: matched.length, samples, scoped };
+}
+function weightOf($, selector) {
+    return elementsOf($, selector).reduce((total, el) => total + textOf($, el).length, 0);
+}
+export function generateCandidates(html) {
+    const $ = loadPage(html);
+    const groups = groupsOf($);
+    const proposals = new Map();
+    // The bare signature first, so that when a scoped form turns out to select
+    // the same elements the shorter one is the survivor.
+    for (const group of groups)
+        proposals.set(group.signature, false);
+    const addresses = new Map();
+    for (const group of groups) {
+        const parentAddress = addressOf($, group.parent, ADDRESS_DEPTH, addresses);
+        if (parentAddress === null)
+            continue;
+        const scoped = `${parentAddress} > ${group.signature}`;
+        const matched = new Set(elementsOf($, scoped));
+        // The scoped form has to still reach every element of the group it came
+        // from — an escape this code got wrong would show up here as a selector
+        // that no longer finds its own elements. It does not have to stop there:
+        // a class selector matches by subset while a group is one exact class set,
+        // so a carousel that marks some slides active splits twenty items into
+        // three groups whose shared selector legitimately selects all twenty.
+        // Requiring the group back exactly discarded that selector, which was the
+        // only exact candidate openlibrary had.
+        const reaches = group.elements.every((el) => matched.has(el));
+        if (reaches && matched.size >= 2 && !proposals.has(scoped))
+            proposals.set(scoped, true);
+    }
+    const built = [];
+    const seen = new Set();
+    const index = new Map();
+    elementsOf($, '*').forEach((el, i) => index.set(el, i));
+    for (const [selector, scoped] of proposals) {
+        const candidate = materialize($, selector, scoped);
+        if (candidate === null)
+            continue;
+        const identity = elementsOf($, selector).map((el) => index.get(el)).join(',');
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        built.push(candidate);
+    }
+    // Once per candidate, not once per comparison: the sort asked for each weight
+    // a few thousand times, and each answer read the text of every match.
+    const weights = new Map(built.map((c) => [c.selector, weightOf($, c.selector)]));
+    return built
+        .sort((a, b) => weights.get(b.selector) - weights.get(a.selector) || b.count - a.count);
+}

package/dist/src/authoring/contract.js

@@ -0,0 +1,31 @@
+/**
+ * What a learned task must prove, decided from the plan's own capabilities.
+ *
+ * Deterministic on purpose, and deliberately unaware of any result. A contract
+ * chosen from what happened to pass would be a test whose passing grade was
+ * written after the test, which is the one thing a verification model cannot
+ * afford. Nothing here consults the benchmark's oracles either: the oracle
+ * grades this system from outside, and a contract derived from it would make
+ * the engine its own examiner.
+ *
+ * It stays this small until a check exists to justify more. A requirement for
+ * a check nobody has implemented only produces plans that can never verify.
+ *
+ * A search asks for both query checks because neither is enough alone: the
+ * first passes a site that honours the query and answers with the wrong
+ * records, and the second passes a site whose words happen to line up.
+ *
+ * Pagination is required exactly when the plan templates `page`, which is not
+ * the same as the site having pages. Templating it is an authoring act: it
+ * makes `run --page N` a supported operation, and what a task supports is what
+ * it has to be right about. A task whose promise is one page does not template
+ * page, and is not asked to prove anything about it.
+ */
+export function buildContract(intent, templated) {
+    const required = ['non_empty', 'required_fields'];
+    if (intent === 'search' && templated.has('query'))
+        required.push('query_honored', 'lexical_query_consistency');
+    if (templated.has('page'))
+        required.push('pagination_honored');
+    return { required };
+}

package/dist/src/authoring/fields.js

@@ -0,0 +1,86 @@
+import { extractBySelector, parseHtmlFragment } from '../executor/extract.js';
+import { isEl, normalize, signatureOf } from './candidates.js';
+const SAMPLE_COUNT = 3;
+const MAX_CANDIDATES = 40;
+/** How many ancestors a descendant's spec may name before it is too brittle. */
+const SPEC_DEPTH = 3;
+/** Attributes worth reading. Everything else on a page is styling or state. */
+const ATTRIBUTES = ['href', 'src', 'id'];
+/** Elements whose content is not data: script, style, noscript, template. */
+const NOISE = new Set(['script', 'style', 'noscript', 'template']);
+const attributesOf = ($, el) => [...ATTRIBUTES, ...Object.keys(el.attribs ?? {}).filter((a) => a.startsWith('data-'))]
+    .filter((a) => ($(el).attr(a) ?? '') !== '');
+/**
+ * The shortest selector naming this descendant inside its item, or null when
+ * three levels were not enough to name it alone. Ambiguity is dropped rather
+ * than guessed at: with many descendants to choose from, one that cannot be
+ * addressed uniquely is not worth offering.
+ */
+function relativeSpec($, item, el, matches) {
+    let spec = signatureOf($, el);
+    let node = el;
+    for (let depth = 0; depth < SPEC_DEPTH; depth++) {
+        if (matches(spec) === 1)
+            return spec;
+        const parent = node.parent;
+        if (parent === null || !isEl(parent) || parent === item)
+            return null;
+        spec = `${signatureOf($, parent)} > ${spec}`;
+        node = parent;
+    }
+    return null;
+}
+export function fieldCandidates(html, itemSelector, limit = MAX_CANDIDATES) {
+    const $ = parseHtmlFragment(html);
+    const items = $(itemSelector).toArray().filter(isEl);
+    if (items.length === 0)
+        return [];
+    const specs = new Set();
+    for (const item of items) {
+        specs.add('');
+        for (const attr of attributesOf($, item))
+            specs.add(`@${attr}`);
+        // Descendants of one item share most signatures, and each `find` walks the
+        // whole item subtree: on a page-sized item that was 60 seconds of asking
+        // the same question. Same call, asked once per spec.
+        const counts = new Map();
+        const matches = (spec) => {
+            let n = counts.get(spec);
+            if (n === undefined) {
+                n = $(item).find(spec).length;
+                counts.set(spec, n);
+            }
+            return n;
+        };
+        for (const el of $(item).find('*').toArray().filter(isEl)) {
+            if (NOISE.has(el.tagName.toLowerCase()))
+                continue;
+            const rel = relativeSpec($, item, el, matches);
+            if (rel === null)
+                continue;
+            specs.add(rel);
+            for (const attr of attributesOf($, el))
+                specs.add(`${rel}@${attr}`);
+        }
+    }
+    // Filter out specs with escaped @ before extraction, as they would be misparsed by the engine
+    const validSpecs = [...specs].filter((spec) => !spec.includes('\\@'));
+    // One extraction with every spec as its own field: the values are then read
+    // exactly as the engine would read them, in a single parse.
+    const named = validSpecs.map((spec, i) => [`f${i}`, spec]);
+    const rows = extractBySelector(html, itemSelector, Object.fromEntries(named));
+    const built = named.map(([name, spec]) => {
+        const values = rows.map((row) => normalize(String(row[name] ?? '')));
+        const present = values.filter((v) => v !== '');
+        return {
+            spec,
+            coverage: present.length / values.length,
+            distinct: new Set(present).size / values.length,
+            samples: present.slice(0, SAMPLE_COUNT),
+        };
+    });
+    return built
+        .filter((c) => c.coverage > 0)
+        .sort((a, b) => b.coverage - a.coverage || b.distinct - a.distinct || a.spec.length - b.spec.length)
+        .slice(0, limit);
+}

package/dist/src/authoring/learn.js

@@ -0,0 +1,51 @@
+import { captureDom } from './snapshot.js';
+import { generateCandidates } from './candidates.js';
+import { fieldCandidates } from './fields.js';
+/**
+ * One browser visit, turned into the options an agent chooses between.
+ *
+ * Nothing is stored and nothing is decided. The ranking is the order of a list
+ * somebody else reads: the item-selector heuristic put the right answer first
+ * on none of six labelled pages and second or third on five of them, which is
+ * a bad ranker and a fine shortlist. The one site tried outside that corpus,
+ * Hacker News, put the answer seventh, so the default has to reach past
+ * "second or third" to still be useful off the labelled set.
+ */
+const DEFAULT_DEPTH = 10;
+const FIELDS_PER_ITEM = 12;
+export function learnFromHtml(url, html, depth = DEFAULT_DEPTH) {
+    const items = generateCandidates(html)
+        .slice(0, depth)
+        .map((candidate) => ({
+        candidate,
+        fields: fieldCandidates(html, candidate.selector, FIELDS_PER_ITEM),
+    }));
+    return { url, items };
+}
+export async function learn(url, depth = DEFAULT_DEPTH) {
+    return learnFromHtml(url, (await captureDom(url)).html, depth);
+}
+const pct = (v) => v.toFixed(2);
+/**
+ * Every line here is a fragment of a command someone will run, so a spec has
+ * to survive being pasted into one. A class carrying `$` or a backtick, which
+ * this generator escapes and therefore can produce, is mangled by a
+ * double-quoted shell; single quotes are the encoding that matches the context.
+ */
+export const shell = (value) => `'${value.replaceAll("'", String.raw `'\''`)}'`;
+/** Visibly cut, so a value that diverges past the cut cannot look identical. */
+const clip = (value, width) => value.length <= width ? value : `${value.slice(0, width - 1)}…`;
+export function formatLearn(report) {
+    const lines = [report.url, ''];
+    report.items.forEach(({ candidate, fields }, i) => {
+        lines.push(`${i + 1}. --items ${shell(candidate.selector)}   ${candidate.count} items`);
+        if (candidate.samples[0] !== undefined)
+            lines.push(`     sample: ${candidate.samples[0].slice(0, 90)}`);
+        for (const f of fields) {
+            lines.push(`     --field NAME=${shell(f.spec).padEnd(34)} ` +
+                `cover ${pct(f.coverage)} distinct ${pct(f.distinct)}  ${clip(f.samples[0] ?? '', 60)}`);
+        }
+        lines.push('');
+    });
+    return lines.join('\n');
+}

package/dist/src/authoring/plans.js

@@ -0,0 +1,93 @@
+import { atomicWrite, siteName, intentName, publicUrl, PlanVerificationSchema } from '../local.js';
+import { mkdir, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { renderUrlTemplate } from '../recipes/template.js';
+/**
+ * A plan an agent taught, as a file.
+ *
+ * `benchmark/plans.ts` is the benchmark's fixed input and must not start
+ * varying with what anyone has learned, so learned plans live apart and carry
+ * their own origin. That is what removes the need to edit two TypeScript files
+ * before the engine can visit a site it has never seen.
+ */
+export const LearnedPlanSchema = z.object({
+    origin: z.string().url(),
+    /** Rendered against the task's input, so one plan serves every input. */
+    urlTemplate: z.string().min(1),
+    itemSelector: z.string().min(1),
+    fields: z.record(z.string()).refine((f) => Object.keys(f).length > 0, 'a plan with no fields extracts nothing'),
+    /**
+     * What this task must prove, and what it has proven. Optional because plans
+     * taught before contracts existed must keep loading; without one a run is
+     * reported as structural and never as verified.
+     */
+    verification: PlanVerificationSchema.optional(),
+});
+const INTENTS = ['search', 'list', 'detail'];
+export async function saveLearnedPlan(dir, site, intent, plan) {
+    siteName(site);
+    intentName(intent);
+    const parsed = LearnedPlanSchema.parse(plan);
+    publicUrl(parsed.origin);
+    await mkdir(join(dir, site), { recursive: true });
+    const path = join(dir, site, `${intent}.json`);
+    await atomicWrite(path, `${JSON.stringify(parsed, null, 2)}\n`);
+    return path;
+}
+/**
+ * Hand-written plans with learned ones layered over them, per intent.
+ *
+ * Merging at the site key instead would drop every hand-written intent for a
+ * site the moment one of its intents was taught.
+ */
+export function mergePlans(hand, learned) {
+    const merged = { ...hand };
+    for (const [site, intents] of Object.entries(learned)) {
+        merged[site] = { ...merged[site], ...intents };
+    }
+    return merged;
+}
+export async function loadLearnedPlans(dir) {
+    const sites = await readdir(dir, { withFileTypes: true }).catch((error) => { if (error.code === 'ENOENT')
+        return []; throw error; });
+    const plans = {};
+    const origins = {};
+    const verifications = {};
+    const rawPlans = {};
+    for (const entry of sites) {
+        if (!entry.isDirectory())
+            continue;
+        for (const intent of INTENTS) {
+            const path = join(dir, entry.name, `${intent}.json`);
+            const raw = await readFile(path, 'utf8').catch((error) => { if (error.code === 'ENOENT')
+                return null; throw error; });
+            if (raw === null)
+                continue;
+            let plan;
+            try {
+                plan = LearnedPlanSchema.parse(JSON.parse(raw));
+            }
+            catch (cause) {
+                throw new Error(`corrupt learned plan at ${path}`, { cause });
+            }
+            publicUrl(plan.origin);
+            if (origins[entry.name] && origins[entry.name] !== plan.origin)
+                throw new Error(`conflicting origins for ${entry.name}`);
+            origins[entry.name] = plan.origin;
+            if (plan.verification)
+                verifications[entry.name] = { ...verifications[entry.name], [intent]: plan.verification };
+            rawPlans[entry.name] = { ...rawPlans[entry.name], [intent]: plan };
+            plans[entry.name] = {
+                ...plans[entry.name],
+                [intent]: {
+                    url: (origin, task) => renderUrlTemplate(origin, plan.urlTemplate, task.input),
+                    sameOriginOnly: true,
+                    itemSelector: plan.itemSelector,
+                    fields: plan.fields,
+                },
+            };
+        }
+    }
+    return { plans, origins, verifications, raw: rawPlans };
+}

package/dist/src/authoring/snapshot.js

@@ -0,0 +1,22 @@
+import { SETTLE_MS } from '../browser/navigate.js';
+import { openSession } from '../browser/session.js';
+const NAVIGATION_TIMEOUT_MS = 30_000;
+/**
+ * One rendered DOM, saved so that a hand-written label keeps its meaning. A
+ * label attached to a live page rots when the site edits its markup, and two of
+ * the sites worth labelling already refuse this machine.
+ */
+export async function captureDom(url) {
+    const session = await openSession();
+    try {
+        await session.page.goto(url, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT_MS });
+        await session.page
+            .waitForLoadState('networkidle', { timeout: NAVIGATION_TIMEOUT_MS })
+            .catch(() => undefined);
+        await session.page.waitForTimeout(SETTLE_MS);
+        return { html: await session.page.content(), capturedAt: new Date().toISOString() };
+    }
+    finally {
+        await session.close();
+    }
+}

package/dist/src/authoring/teach.js

@@ -0,0 +1,136 @@
+import { siteName, intentName, publicUrl, requireReadable } from '../local.js';
+import { browserItemsOf } from '../compiler/verify.js';
+import { record } from '../recorder/index.js';
+import { HeuristicCompiler, templatePath, templatedInputs } from '../compiler/heuristic.js';
+import { compileHtmlRecipe } from '../compiler/html.js';
+import { isRefused } from '../compiler/types.js';
+import { RecipeRegistry } from '../recipes/registry.js';
+import { StaticSiteResolver } from '../sites.js';
+import { LearnedPlanSchema, saveLearnedPlan } from './plans.js';
+import { buildContract } from './contract.js';
+import { runQueryProbes, verifyQueryHonored } from '../verification/query-honored.js';
+import { verifyLexicalConsistency } from '../verification/lexical-consistency.js';
+import { runPaginationProbes, verifyPaginationHonored } from '../verification/pagination-honored.js';
+import { Probes, runBaseline } from '../verification/probes.js';
+import { renderUrlTemplate } from '../recipes/template.js';
+import { PolitenessLayer } from '../net/politeness.js';
+export async function teach(opts) {
+    siteName(opts.site);
+    intentName(opts.intent);
+    const url = publicUrl(opts.url);
+    const path = templatePath(url.pathname, opts.input);
+    const query = [...url.searchParams.entries()]
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(templatePath(v, opts.input)).replace(/%7B%7B(\w+)%7D%7D/g, '{{$1}}')}`)
+        .join('&');
+    const urlTemplate = `${path}${query === '' ? '' : `?${query}`}`;
+    // A url template that does not carry an input as a placeholder returns the
+    // recorded page for every value of that input, forever, with validation
+    // passing every time — the plan itself would be the broken thing, unlike a
+    // refusal from the compiler that just means the browser fallback must answer.
+    const templated = templatedInputs([urlTemplate]);
+    const missing = Object.entries(opts.input)
+        .filter(([, v]) => String(v) !== '')
+        .map(([name]) => name)
+        .filter((name) => !templated.has(name));
+    if (missing.length > 0) {
+        throw new Error(`urlTemplate "${urlTemplate}" does not template input(s): ${missing.join(', ')}`);
+    }
+    // The contract is fixed from what the plan can vary, before a single result
+    // is seen. Evidence is filled in below by whatever actually ran.
+    const contract = buildContract(opts.intent, templated);
+    const plan = LearnedPlanSchema.parse({
+        origin: url.origin,
+        urlTemplate,
+        itemSelector: opts.itemSelector,
+        fields: opts.fields,
+        verification: { contract, evidence: {} },
+    });
+    const browserPlan = {
+        url: () => opts.url,
+        itemSelector: plan.itemSelector,
+        fields: plan.fields,
+    };
+    const sites = new StaticSiteResolver({ [opts.site]: plan.origin });
+    const task = { id: 'teach', site: opts.site, intent: opts.intent, input: opts.input };
+    const trace = await record(browserPlan, task, sites);
+    try {
+        const items = browserItemsOf(trace, browserPlan);
+        requireReadable(items, Object.keys(plan.fields));
+        // Only checks something actually ran are recorded. A required check with no
+        // entry reads back as not_tested, which is the truth; writing that status
+        // here would store an outcome no verifier produced.
+        plan.verification = {
+            contract,
+            evidence: { non_empty: { status: 'passed' }, required_fields: { status: 'passed' } },
+        };
+        const refusals = [];
+        let recipe = null;
+        const json = await new HeuristicCompiler(browserPlan).compile(trace);
+        if (isRefused(json))
+            refusals.push(`json: ${json.refused}`);
+        else
+            recipe = json;
+        if (recipe === null) {
+            const html = compileHtmlRecipe(trace, browserPlan);
+            if (isRefused(html))
+                refusals.push(`html: ${html.refused}`);
+            else
+                recipe = html;
+        }
+        // A recipe reaching past the site's own host is refused rather than stored.
+        // It is tolerable while every recipe is compiled locally from a site the
+        // caller chose, and it is not tolerable once recipes are shared, so the rule
+        // is set before anything depends on the looser one.
+        if (recipe !== null && recipe.request.origin !== undefined && recipe.request.origin !== plan.origin) {
+            refusals.push(`recipe reaches ${recipe.request.origin}, outside ${plan.origin}`);
+            recipe = null;
+        }
+        // Probing needs a recipe to judge and a contract that asks for something.
+        // It reads the compiled recipe and writes nothing, so a failed probe leaves
+        // the plan and the registry exactly as a skipped one does.
+        const wantsQuery = contract.required.includes('query_honored');
+        const wantsPagination = contract.required.includes('pagination_honored');
+        if (recipe !== null && (wantsQuery || wantsPagination) && !opts.skipSemanticVerification) {
+            const probes = new Probes({
+                recipe,
+                browserPlan: {
+                    url: (origin, probe) => renderUrlTemplate(origin, plan.urlTemplate, probe.input),
+                    sameOriginOnly: true,
+                    itemSelector: plan.itemSelector,
+                    fields: plan.fields,
+                },
+                site: opts.site,
+                intent: opts.intent,
+                input: opts.input,
+                net: new PolitenessLayer({ minIntervalMs: opts.minIntervalMs }),
+                sites,
+            });
+            // One baseline for every check. Neither check may depend on the other
+            // having run: a list task that pages but takes no query still has to be
+            // able to prove its pagination.
+            const baseline = await runBaseline(probes, opts.input, wantsQuery ? 'query' : 'page', items);
+            if (wantsQuery) {
+                const session = await runQueryProbes(probes, baseline, 'query');
+                plan.verification.evidence.query_honored = verifyQueryHonored(session);
+                plan.verification.evidence.lexical_query_consistency = verifyLexicalConsistency(session);
+            }
+            if (wantsPagination) {
+                plan.verification.evidence.pagination_honored = verifyPaginationHonored(await runPaginationProbes(probes, baseline, 'page'));
+            }
+        }
+        // A refused compile must not leave an earlier task's recipe active.
+        const registry = new RecipeRegistry(opts.recipeDir);
+        await registry.remove(opts.site, opts.intent);
+        const planPath = await saveLearnedPlan(opts.planDir, opts.site, opts.intent, plan);
+        await registry.clearLearningFailure(opts.site, opts.intent);
+        const refused = recipe === null ? refusals.join('; ') : null;
+        if (recipe !== null)
+            await registry.save(recipe);
+        else
+            await registry.setLearningFailure(opts.site, opts.intent, refused);
+        return { plan, planPath, recipe, refused, sample: items.slice(0, 3) };
+    }
+    finally {
+        await trace.dispose?.();
+    }
+}