@reddoorla/maintenance 0.91.0 → 0.93.0

package/dist/{chunk-WVVT6SJK.js → chunk-BJQCIJOY.js}

@@ -1,6 +1,6 @@
 import {
   checkGoal
-} from "./chunk-RQLXEMEE.js";
+} from "./chunk-T7ZUUOZ2.js";
 import {
   isPrivateOrLoopbackHost
 } from "./chunk-RARREDQE.js";
@@ -1273,6 +1273,10 @@ Return:
   at it with a pronoun has no antecedent and the engine will answer that it does not know who is meant.
   These are searches, not conversational questions, and they are not the buyerQuestions above.
 - fixes: prioritized, concrete, specific to this site. No generic SEO advice.
+  Each "why" describes what a buyer or a crawler can or cannot read on the site TODAY. Never predict
+  what an answer engine will cite, repeat, rank or recommend: the report states elsewhere, with
+  evidence, that nothing on the site reliably moves that, and a fix that promises it contradicts the
+  report. "A buyer cannot find a price" is a reason; "an engine will have nothing to cite" is not.
   Set addresses to the key of the measured requirement a fix would satisfy \u2014 one of the keys listed
   under "What we have already measured", exactly as written \u2014 or null when it answers to none of them.
   Null is the normal case: a heavy image, a broken link or a stale copyright year maps to no
@@ -1462,7 +1466,12 @@ async function analyzeSite(url, crawl, checks, deps = defaultAnalyzeDeps(), goal
     ...parsed,
     questionSetId: set.id,
     buyerQuestions: conformToSet(parsed.buyerQuestions, set),
-    fixes: reconcileFixes(parsed.fixes, goalFit)
+    // Stamped here, at the one place model fixes enter the system, so the
+    // renderer can label them as judgement and never as a finding.
+    fixes: reconcileFixes(parsed.fixes, goalFit).map((f) => ({
+      ...f,
+      origin: "recommendation"
+    }))
   };
   return verifyEvidence(conformed, crawl);
 }
@@ -2050,6 +2059,7 @@ async function classifyDomains(prospectUrl, prospectPhones, domains, deps) {
 var MAX_PAGES2 = 14;
 var MAX_TOTAL_CHARS = 12e4;
 var MAX_ASSERTIONS = 12;
+var NO_CONFLATION = { detected: false, otherNames: [], engineQuote: null };
 var AccuracySchema = z2.object({
   assertions: z2.array(
     z2.object({
@@ -2065,7 +2075,15 @@ var AccuracySchema = z2.object({
        */
       searchTerms: z2.array(z2.string()).min(1).max(6)
     })
-  ).max(MAX_ASSERTIONS)
+  ).max(MAX_ASSERTIONS),
+  /** Does the answer describe MORE THAN ONE business under this name, or a
+   *  different business first? Defaulted, so a model that omits it reads as
+   *  "not detected" rather than failing the whole stage. */
+  conflation: z2.object({
+    detected: z2.boolean(),
+    otherNames: z2.array(z2.string()).max(6),
+    engineQuote: z2.string().nullable()
+  }).default({ detected: false, otherNames: [], engineQuote: null })
 });
 function makeFenceTag2() {
   return `data_${randomBytes2(6).toString("hex")}`;
@@ -2103,6 +2121,12 @@ For each assertion return:
 - searchTerms: 1-6 distinctive words or short phrases you would search the site for to find this fact \u2014
   proper nouns, numbers, street names. These are used to re-check "absent" verdicts across pages you were
   not shown, so choose terms that would actually appear if the fact were stated somewhere else on the site.
+
+Separately, return "conflation": does the answer describe MORE THAN ONE business under this name, or
+describe a different business first? If so, detected is true, otherNames lists the OTHER businesses
+named (never this one), and engineQuote is the exact sentence that says the name belongs to several
+businesses \u2014 copied verbatim, it is checked against the answer character by character. Otherwise
+detected is false with an empty otherNames and a null engineQuote.
   Avoid generic words ("dental", "services") that appear on every page.
 
 Be conservative about "confirmed": if the site only gestures at the fact, that is "absent". Being wrong in
@@ -2268,28 +2292,40 @@ function quoteSupportsClaim(claim, quote) {
   for (const w of words(claim)) if (inQuote.has(w)) shared += 1;
   return shared >= 2;
 }
-function verifyQuotes(raw, answerText, siteText, answerOf, prospectDomain) {
+function verifyQuotes(raw, answerText, siteText, answerOf, prospectDomain, searchTermsByClaim = /* @__PURE__ */ new Map()) {
   const answers = normalize(answerText);
   const site = normalize(siteText);
+  const flat = siteText.replace(/\s+/g, " ");
   const out = [];
   for (const a of raw) {
     if (!answers.includes(normalize(a.engineQuote))) continue;
+    let verdict = a.verdict;
+    let siteQuote = a.siteQuote;
+    if (a.verdict === "contradicted") {
+      for (const term of distinctive(searchTermsByClaim.get(a.claim) ?? [])) {
+        if (findTerm(site, term) !== "exact") continue;
+        const at = site.indexOf(normalize(term));
+        verdict = "confirmed";
+        siteQuote = flat.slice(Math.max(0, at - 80), at + term.length + 80).trim();
+        break;
+      }
+    }
     const from = answerOf.get(normalize(a.engineQuote));
     const sourceDomains = [
       ...new Set((from?.citedDomains ?? []).map(domainOf).filter((d) => d !== prospectDomain))
     ];
-    const quoteReal = a.siteQuote !== null && site.includes(normalize(a.siteQuote));
-    const needsQuote = a.verdict === "confirmed" || a.verdict === "contradicted";
-    const quoteSupports = quoteReal && a.siteQuote !== null && quoteSupportsClaim(a.claim, a.siteQuote);
+    const quoteReal = siteQuote !== null && site.includes(normalize(siteQuote));
+    const needsQuote = verdict === "confirmed" || verdict === "contradicted";
+    const quoteSupports = quoteReal && siteQuote !== null && quoteSupportsClaim(a.claim, siteQuote);
     const unsupported = needsQuote && (!quoteReal || !quoteSupports);
     out.push({
       claim: a.claim,
-      verdict: unsupported ? "unverified" : a.verdict,
+      verdict: unsupported ? "unverified" : verdict,
       engineQuote: a.engineQuote,
       // Kept when it is real, even where it does not carry the claim: the
       // reader can see what we looked at and judge it themselves, which is a
       // better position than being told we found nothing.
-      siteQuote: quoteReal ? a.siteQuote : null,
+      siteQuote: quoteReal ? siteQuote : null,
       nearbyMention: null,
       unverifiedReason: !unsupported ? null : !quoteReal ? "We could not find the passage this was based on, so we have not stated it either way." : "The passage we found is about the same subject but does not actually say this, so we have not stated it either way.",
       sourceDomains,
@@ -2332,11 +2368,13 @@ async function checkAccuracy(url, crawl, answers, prospectPhones, deps) {
       siteFullyRead: false,
       pagesRead: 0,
       pagesTotal: crawl.pages.length,
-      answersRead: 0
+      answersRead: 0,
+      conflation: NO_CONFLATION
     };
   }
   const input = buildAccuracyInput(crawl, branded);
   const parsed = AccuracySchema.parse(await deps.run(input));
+  const termsByClaim = new Map(parsed.assertions.map((a) => [a.claim, a.searchTerms]));
   const answerOf = /* @__PURE__ */ new Map();
   for (const a of branded) {
     const text = normalize(a.fullAnswer ?? "");
@@ -2346,14 +2384,17 @@ async function checkAccuracy(url, crawl, answers, prospectPhones, deps) {
     }
   }
   const siteText = fullSiteText(crawl);
+  const answerText = branded.map((a) => a.fullAnswer ?? "").join("\n");
   const verified = verifyQuotes(
     parsed.assertions,
-    branded.map((a) => a.fullAnswer ?? "").join("\n"),
+    answerText,
     siteText,
     answerOf,
-    domainOf(url)
+    domainOf(url),
+    termsByClaim
   );
-  const termsByClaim = new Map(parsed.assertions.map((a) => [a.claim, a.searchTerms]));
+  const c = parsed.conflation;
+  const conflation = c.detected && c.engineQuote !== null && normalize(answerText).includes(normalize(c.engineQuote)) ? { detected: true, otherNames: c.otherNames, engineQuote: c.engineQuote } : NO_CONFLATION;
   const sources = await classifyDomains(
     url,
     prospectPhones,
@@ -2366,7 +2407,8 @@ async function checkAccuracy(url, crawl, answers, prospectPhones, deps) {
     siteFullyRead: input.fullyRead,
     pagesRead: input.pagesRead,
     pagesTotal: crawl.pages.length,
-    answersRead: branded.length
+    answersRead: branded.length,
+    conflation
   };
 }
 
@@ -3155,6 +3197,99 @@ async function checkBasics(crawl, deps) {
   };
 }
 
+// src/prospect/measured-fixes.ts
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+function measuredFixes(input) {
+  const out = [];
+  const c = input.checks;
+  if (c && c.crawlerAccessMeasured && c.crawlerAccess.blockedAi.length > 0) {
+    const names = c.crawlerAccess.blockedAi.join(", ");
+    out.push({
+      title: `Let ${names} read your site`,
+      why: `Your robots.txt turns away ${names}. A crawler that is refused cannot read a page, so nothing else in this report can help for it until this changes.`,
+      impact: "high",
+      effort: "low",
+      tier: "crawl",
+      addresses: null,
+      origin: "measured"
+    });
+  }
+  for (const r of input.goalFit?.requirements ?? []) {
+    if (r.status !== "missing") continue;
+    out.push({
+      title: r.label.charAt(0).toUpperCase() + r.label.slice(1),
+      why: r.why,
+      impact: "high",
+      effort: r.scope === "quick" ? "low" : r.scope === "content" ? "medium" : "high",
+      tier: r.scope === "quick" ? "technical" : "content",
+      addresses: r.key,
+      origin: "measured"
+    });
+  }
+  const phoneJudgedByGoal = (input.goalFit?.requirements ?? []).some(
+    (r) => r.key === "tappable-phone"
+  );
+  const plain = phoneJudgedByGoal ? 0 : (input.phones ?? []).filter((p) => p.linked === false).length;
+  if (plain > 0) {
+    out.push({
+      title: "Make your phone number tappable",
+      why: `${plural(plain, "number is", "numbers are")} written as plain text. On a phone that is something a visitor has to memorise and retype; as a link it is one tap, and it is the moment they were most likely to call.`,
+      impact: "medium",
+      effort: "low",
+      tier: "technical",
+      addresses: null,
+      origin: "measured"
+    });
+  }
+  if (input.brokenLinks !== null && input.brokenLinks > 0) {
+    out.push({
+      title: `Repair ${plural(input.brokenLinks, "broken link", "broken links")}`,
+      why: "A visitor who follows one lands on an error page, and a crawler that follows one stops there.",
+      impact: "medium",
+      effort: "low",
+      tier: "technical",
+      addresses: null,
+      origin: "measured"
+    });
+  }
+  if (input.brokenImages !== null && input.brokenImages > 0) {
+    out.push({
+      title: `Replace ${plural(input.brokenImages, "broken image", "broken images")}`,
+      why: "It shows as an empty box or a missing-image icon on the page a visitor is reading.",
+      impact: "low",
+      effort: "low",
+      tier: "technical",
+      addresses: null,
+      origin: "measured"
+    });
+  }
+  if (c) {
+    if (c.headings.pagesWithoutH1 > 0) {
+      out.push({
+        title: `Give ${plural(c.headings.pagesWithoutH1, "page", "pages")} a top heading`,
+        why: `${c.headings.pagesWithoutH1} of ${c.meta.pageCount} pages have no top-level heading, so a reader or a crawler arriving on them is not told what the page is about.`,
+        impact: "medium",
+        effort: "low",
+        tier: "technical",
+        addresses: null,
+        origin: "measured"
+      });
+    }
+    if (c.meta.missingCanonical > 0) {
+      out.push({
+        title: "Tell search engines which address is the real one for each page",
+        why: `${c.meta.missingCanonical} of ${c.meta.pageCount} pages do not declare a canonical address. When the same page is reachable at more than one address, a search engine has to guess which one to keep.`,
+        impact: "medium",
+        effort: "low",
+        tier: "technical",
+        addresses: null,
+        origin: "measured"
+      });
+    }
+  }
+  return out;
+}
+
 // src/prospect/pipeline.ts
 function envAnalyzeDeps(factories = {
   api: defaultAnalyzeDeps,
@@ -3215,6 +3350,10 @@ async function stage(name, deps, fn) {
     return { ok: false, error };
   }
 }
+function mergeFixes(measured, model) {
+  const covered = new Set(measured.map((f) => f.addresses).filter((k) => !!k));
+  return [...measured, ...model.filter((f) => !(f.addresses && covered.has(f.addresses)))];
+}
 async function runProspectAudit(url, opts, deps = {}) {
   const llmAuth = llmAuthMode();
   const crawlDeps = deps.crawl ?? defaultCrawlDeps();
@@ -3320,9 +3459,21 @@ async function runProspectAudit(url, opts, deps = {}) {
       checks.ok ? checks.data : null
     )
   };
-  const reconciled = analyze.ok && goalFit.ok ? {
+  const reconciled = analyze.ok ? {
     ok: true,
-    data: { ...analyze.data, fixes: reconcileFixes(analyze.data.fixes, goalFit.data) }
+    data: {
+      ...analyze.data,
+      fixes: mergeFixes(
+        measuredFixes({
+          goalFit: goalFit.ok ? goalFit.data : null,
+          checks: checks.ok ? checks.data : null,
+          phones: checks.ok ? checks.data.consistency?.phones ?? null : null,
+          brokenLinks: assets.ok ? assets.data.brokenLinks.length : null,
+          brokenImages: assets.ok ? assets.data.brokenImages.length : null
+        }),
+        goalFit.ok ? reconcileFixes(analyze.data.fixes, goalFit.data) : analyze.data.fixes
+      )
+    }
   } : analyze;
   const brandedAnswers = probes.ok ? probes.data.answers.filter((a) => a.kind === "branded") : [];
   const accuracy = brandedAnswers.length === 0 ? { ok: false, error: ACCURACY_SKIPPED } : await stage("accuracy", deps, async () => {
@@ -3377,6 +3528,7 @@ export {
   GOAL_UNRESOLVED,
   ASSET_ACCEPT,
   defaultAssetProbe,
+  mergeFixes,
   runProspectAudit
 };
-//# sourceMappingURL=chunk-WVVT6SJK.js.map
+//# sourceMappingURL=chunk-BJQCIJOY.js.map