@nextcommerce/campaigns-os 1.62.0 → 1.66.0

package/src/commercial-parity.mjs

@@ -1,8 +1,11 @@
 /**
  * Dependency-free extraction and Exact-only commercial parity comparison.
  *
- * Source HTML is intentional: Campaign Cart replaces authored placeholders
- * after readiness, which can hide an authored mismatch in the rendered DOM.
+ * Source HTML is intentional for bundle prices: Campaign Cart replaces authored
+ * placeholders after readiness, which can hide an authored mismatch in the
+ * rendered DOM. package.price is the other way round: its authored text is a
+ * template placeholder no shopper is meant to read, so only its rendered value
+ * is compared and the source merely says the claim exists.
  */
 
 import {
@@ -416,6 +419,48 @@ function governedPriceBinding(value) {
   return typeof value === "string" && /^bundle\.[^.]+\.price$/.test(value.trim());
 }
 
+// The SDK's own package.price paths: an id in the path, or none and the nearest
+// package id around the node. No other package.* field is a price claim here.
+const PACKAGE_PRICE_BINDING = /^package\.(?:([1-9]\d*)\.)?price$/;
+const PACKAGE_CONTEXT_ATTRIBUTES = Object.freeze(["data-next-package-id", "data-next-package", "data-package-id"]);
+
+export const PACKAGE_PRICE_NOT_RENDERED = "package_price_not_rendered";
+export const PACKAGE_PRICE_NOT_FILLED = "package_price_not_filled";
+export const PACKAGE_PRICE_UNRESOLVED = "package_price_unresolved";
+
+function packageContextId(node) {
+  for (let current = node; current; current = current.parent) {
+    for (const attribute of PACKAGE_CONTEXT_ATTRIBUTES) {
+      const id = positiveInteger(current.attrs?.[attribute]);
+      if (id !== null) return id;
+    }
+  }
+  return null;
+}
+
+// Lists the claims, deliberately without their text: what the source holds is
+// the template's placeholder, and comparing it would report every starter page.
+function extractPackagePrices(nodeIndex, consumeClaim) {
+  const seen = new Set();
+  const claims = [];
+  nodeIndex.nodes.forEach((node) => {
+    const binding = String(node.attrs?.["data-next-display"] || "").trim();
+    const match = PACKAGE_PRICE_BINDING.exec(binding);
+    const format = String(node.attrs?.["data-next-format"] || "currency").trim().toLowerCase();
+    if (!match
+      || format !== "currency"
+      || nodeIndex.hidden.get(node) === true
+      || nodeIndex.comparison.get(node) === true) return;
+    const packageId = positiveInteger(match[1]) ?? packageContextId(node);
+    const key = `${binding}\u0000${packageId}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    consumeClaim();
+    claims.push({ binding, package_id: packageId });
+  });
+  return claims;
+}
+
 function extractPrices(nodeIndex, consumeClaim) {
   const seen = new Set();
   const prices = [];
@@ -529,6 +574,7 @@ export function extractCommercialClaims(html, options = {}) {
     }
   };
   const priceClaims = extractPrices(nodeIndex, consumeClaim);
+  const packagePriceClaims = extractPackagePrices(nodeIndex, consumeClaim);
   const recurrenceClaims = extractRecurrences(nodeIndex, extractionErrors, consumeClaim);
   const vouchers = extractVouchers(nodeIndex, extractionErrors, consumeClaim);
   return {
@@ -537,6 +583,7 @@ export function extractCommercialClaims(html, options = {}) {
     price_claims: priceClaims,
     recurrence_claims: recurrenceClaims,
     vouchers,
+    ...(packagePriceClaims.length ? { package_price_claims: packagePriceClaims } : {}),
     ...(extractionErrors.length ? { extraction_errors: extractionErrors } : {}),
   };
 }
@@ -563,8 +610,23 @@ function validVoucherClaim(claim) {
   return record(claim) && typeof claim.code === "string" && present(claim.code);
 }
 
+function validPackagePriceClaim(claim) {
+  return record(claim)
+    && typeof claim.binding === "string"
+    && PACKAGE_PRICE_BINDING.test(claim.binding)
+    && (claim.package_id === null || positiveInteger(claim.package_id) !== null);
+}
+
+function validRenderedPackagePrice(claim) {
+  return validPackagePriceClaim(claim)
+    && typeof claim.filled === "boolean"
+    && (claim.text === null || typeof claim.text === "string");
+}
+
 function validCaptureEnvelope(capture) {
   if (!record(capture)) return false;
+  if (capture.package_price_claims !== undefined && !Array.isArray(capture.package_price_claims)) return false;
+  if (capture.rendered_package_prices !== undefined && !Array.isArray(capture.rendered_package_prices)) return false;
   if (capture.page_id !== undefined
     && capture.page_id !== null
     && (typeof capture.page_id !== "string" || !present(capture.page_id))) return false;
@@ -580,7 +642,9 @@ function validCapture(capture) {
   return validCaptureEnvelope(capture)
     && capture.price_claims.every(validPriceClaim)
     && capture.recurrence_claims.every(validRecurrenceClaim)
-    && capture.vouchers.every(validVoucherClaim);
+    && capture.vouchers.every(validVoucherClaim)
+    && array(capture.package_price_claims).every(validPackagePriceClaim)
+    && array(capture.rendered_package_prices).every(validRenderedPackagePrice);
 }
 
 function captureCandidates(capturesValue) {
@@ -626,6 +690,64 @@ function priceComparisonClaims(capture, page) {
   return { compared, unresolved: claims.length - compared.length };
 }
 
+// Printed money as the SDK formats it: a symbol or code around one amount. A
+// decimal comma or anything else stays unread, so it is unresolved, not wrong.
+function renderedMoney(text) {
+  const match = decodeEntities(String(text ?? "")).replace(/[\u00a0\s]+/g, " ").trim()
+    .match(/^[^\d-]*(\d[\d,]*(?:\.\d{1,2})?)\s*[A-Za-z]*$/);
+  return match ? normalizeMoney(match[1]) : null;
+}
+
+// One distinct Exact per-unit price for the package on this page, or nothing:
+// two rows of one package at different unit prices (quantity tiers, say) do not
+// say which one a generic package.price means.
+function exactPackageUnitPrice(page, packageId) {
+  const prices = new Set(array(page?.rows)
+    .filter((row) => String(row?.package_id) === String(packageId))
+    .map((row) => (row?.state === PricingState.Exact ? exactMoneyFact(row?.unit_price)?.value : null)));
+  return prices.size === 1 ? [...prices][0] ?? null : null;
+}
+
+// The rendered read is the authority once it found any. When it found none, the
+// source still says the claims exist, so they are not allowed to disappear.
+export function packagePriceClaimCount(capture) {
+  const rendered = array(capture?.rendered_package_prices);
+  return rendered.length || array(capture?.package_price_claims).length;
+}
+
+/**
+ * Sort a page's package.price claims into compared and unresolved. Only a
+ * rendered value the SDK filled is ever compared. Each unresolved claim names
+ * its reason, so the run can say what to do about it. Distinct claims only: one
+ * price repeated around an upsell page is one claim.
+ */
+function packagePriceComparisonClaims(capture, page) {
+  const rendered = array(capture?.rendered_package_prices);
+  if (!rendered.length) {
+    return {
+      compared: [],
+      unresolved: array(capture?.package_price_claims).map(() => PACKAGE_PRICE_NOT_RENDERED),
+    };
+  }
+  const compared = [];
+  const unresolved = [];
+  const voucherUnpriced = voucherComparisonClaims(capture, page).unresolved > 0;
+  rendered.forEach((claim) => {
+    if (!claim?.filled) {
+      unresolved.push(PACKAGE_PRICE_NOT_FILLED);
+      return;
+    }
+    const value = renderedMoney(claim.text);
+    const truth = claim.package_id === null || voucherUnpriced ? null : exactPackageUnitPrice(page, claim.package_id);
+    if (!value || !truth) {
+      unresolved.push(PACKAGE_PRICE_UNRESOLVED);
+      return;
+    }
+    compared.push({ package_id: claim.package_id, value, truth });
+  });
+  return { compared, unresolved };
+}
+
 function pageForCapture(capture, journey) {
   const pages = array(journey?.pages);
   if (present(capture?.page_id)) {
@@ -745,6 +867,19 @@ export function diffCommercialParity(capturesValue, journey, options = {}) {
       });
     }
 
+    (compareMoney ? packagePriceComparisonClaims(capture, page).compared : []).forEach(({ package_id: packageId, value, truth }) => {
+      if (moneyToCents(value) === moneyToCents(truth)) return;
+      findings.push({
+        type: "price-claim-mismatch",
+        page_id: pageId,
+        ...source,
+        binding: `package.${packageId}.price`,
+        package_id: packageId,
+        claimed: value,
+        calculated: truth,
+      });
+    });
+
     (compareMoney ? recurrenceComparisonClaims(capture, page).compared : []).forEach(({ claim, truth }) => {
       const packageId = positiveInteger(claim?.package_id);
       const claimed = {
@@ -817,7 +952,11 @@ function assertionForFinding(finding, id) {
       ...common,
       expected: finding.calculated,
       actual: finding.claimed,
-      evidence: { type: finding.type, binding: finding.binding },
+      evidence: {
+        type: finding.type,
+        binding: finding.binding,
+        ...(finding.package_id !== undefined ? { package_id: finding.package_id } : {}),
+      },
     };
   }
   if (finding.type === "cadence-disclosure-mismatch") {
@@ -952,7 +1091,7 @@ export function createCommercialParityReport(capturesValue, journey, options = {
     .filter((page) => !pageKeys.has(String(page?.page_id ?? "page")))
     .map((page) => ({ page_id: present(page?.page_id) ? String(page.page_id) : null }));
   const extractedPriceClaims = matched.reduce(
-    (sum, { capture }) => sum + capture.price_claims.length,
+    (sum, { capture }) => sum + capture.price_claims.length + packagePriceClaimCount(capture),
     0,
   );
   const extractedRecurrenceClaims = matched.reduce(
@@ -963,12 +1102,22 @@ export function createCommercialParityReport(capturesValue, journey, options = {
     (sum, { capture }) => sum + capture.vouchers.length,
     0,
   );
+  const packagePriceCounts = {
+    extracted: matched.reduce((sum, { capture }) => sum + packagePriceClaimCount(capture), 0),
+    compared: 0,
+  };
+  const packagePriceUnresolved = {};
   const priceComparisonCounts = countsOnly || moneyReason
     ? { compared: 0, unresolved: extractedPriceClaims }
     : matched.reduce((counts, { capture, page }) => {
       const comparison = priceComparisonClaims(capture, page);
-      counts.compared += comparison.compared.length;
-      counts.unresolved += comparison.unresolved;
+      const packagePrices = packagePriceComparisonClaims(capture, page);
+      packagePriceCounts.compared += packagePrices.compared.length;
+      packagePrices.unresolved.forEach((code) => {
+        packagePriceUnresolved[code] = (packagePriceUnresolved[code] || 0) + 1;
+      });
+      counts.compared += comparison.compared.length + packagePrices.compared.length;
+      counts.unresolved += comparison.unresolved + packagePrices.unresolved.length;
       return counts;
     }, { compared: 0, unresolved: 0 });
   const recurrenceComparisonCounts = countsOnly || moneyReason
@@ -1007,6 +1156,7 @@ export function createCommercialParityReport(capturesValue, journey, options = {
     extracted_price_claims: extractedPriceClaims,
     compared_price_claims: priceComparisonCounts.compared,
     unresolved_price_claims: priceComparisonCounts.unresolved,
+    package_price_claims: { ...packagePriceCounts, unresolved: packagePriceUnresolved },
     extracted_recurrence_claims: extractedRecurrenceClaims,
     compared_recurrence_claims: recurrenceComparisonCounts.compared,
     unresolved_recurrence_claims: recurrenceComparisonCounts.unresolved,

package/src/doctor/checks.mjs

@@ -6,7 +6,7 @@ import { accessSync, constants as fsConstants, existsSync, readdirSync, readFile
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { describeSdkIgnoredMetaTags, isSdkIgnoredMetaTag } from "../sdk-meta-tags.mjs";
 import { ORDER_PATH_DEPTH_DRIFT_CODE, orderPathDepthDriftText, orderPathDepthsDisagree } from "../proof-policy.mjs";
-import { QA_GATE_PLACEHOLDER_TEXT_RESIDUE, qaGatePassedForCurrentBuild } from "../stage-ledger.mjs";
+import { QA_GATE_PLACEHOLDER_TEXT_RESIDUE, qaGatePassedForCurrentBuild, qaRestsOnBaseline } from "../stage-ledger.mjs";
 import {
   validateAdapterDecisionGates,
   validateAdapterDecisionShape,
@@ -436,6 +436,15 @@ const SPEC_DOCTOR_CHECKS = createDoctorCheckRegistry([
     phase: "built-output",
     run: ({ packet, errors, warnings, ready, derived, buildState }) => validateBuildOutputFingerprint(packet, errors, warnings, ready, derived, buildState),
   },
+  {
+    id: "qa.baseline_accepted",
+    phase: "built-output",
+    run: ({ warnings, buildState }) => {
+      const baseline = qaRestsOnBaseline(buildState.report);
+      if (!baseline) return;
+      addIssue(warnings, "qa.baseline_accepted", `QA rests on a baseline ${baseline.accepted_by} accepted at ${baseline.accepted_at}, not a test. No purchase has been tested since; a completed full \`campaigns-os qa run\` ends it.`, { accepted_by: baseline.accepted_by, accepted_at: baseline.accepted_at });
+    },
+  },
   {
     id: "built_output.pages",
     phase: "built-output",
@@ -742,7 +751,10 @@ function validatePacket(packet, packetPath, errors, warnings, ready, derived, bu
     } else if (!isNonEmptyString(localSpecPath)) {
       addIssue(errors, "spec.local_path", "No local CampaignSpec path is present. Assembly must use a local exported CampaignSpec JSON so page coverage, routing, meta tags, and commerce refs are not guessed.");
     } else if (!existsSync(specPath)) {
-      addIssue(errors, "spec.local_path", `CampaignSpec local_path does not exist: ${localSpecPath}`);
+      // A saved-Map copy is not on this machine: a checkout made before it was
+      // committed, or a machine that never ran the intake.
+      const restorable = isNonEmptyString(packet.spec?.map_id) && localSpecPath.includes(".campaign-runtime/fetched-specs/");
+      addIssue(errors, "spec.local_path", `CampaignSpec local_path does not exist: ${localSpecPath}${restorable ? `. Restore it from the saved Map with \`campaigns-os spec fetch --packet <packet>\`, then commit it.` : ""}`);
     } else {
       try {
         const loaded = readJson(specPath);
@@ -1910,7 +1922,20 @@ export function validateBuildOutputFingerprint(packet, errors, warnings, ready,
   const publicRouteSlug = normalizePublicRouteSlug(packet?.campaign?.public_route_slug);
   if (!targetRepo || !publicRouteSlug) return;
   const siteRoot = join(targetRepo, "_site", publicRouteSlug);
-  if (!existsSync(siteRoot) || !statSync(siteRoot).isDirectory()) return;
+  if (!existsSync(siteRoot) || !statSync(siteRoot).isDirectory()) {
+    // Nothing to compare, which is not the same as nothing changed: a fresh
+    // checkout has committed records and no _site/, and would otherwise read
+    // as finished however much source has moved since they were made.
+    if (isStageComplete(buildState.report, "assembly")) {
+      addIssue(
+        warnings,
+        "built_output.absent",
+        `_site/${publicRouteSlug}/ is not built here, so the recorded build, Polish and QA were not compared with this checkout. Build it, then run this again.`,
+        { root: `_site/${publicRouteSlug}/` },
+      );
+    }
+    return;
+  }
 
   const current = computeBuildFingerprint(siteRoot);
   // The root was a directory a moment ago; if it is not one now (removed

package/src/doctor/ci.mjs

@@ -36,7 +36,7 @@ const commerceReasonText = new Map([
   ["page_removed", "a page was removed"],
   ["checkout_page", "a checkout page changed"],
   ["commerce_markup_changed", "package, offer, shipping, upsell, route or script markup changed"],
-  ["commerce_signature_unavailable", "the recorded build has no commerce signature to compare against"],
+  ["commerce_signature_unavailable", "the recorded build predates the markup hashes page-only changes are read from (Campaigns OS 1.62), so this change cannot be shown to be page-only"],
   ["campaign_config_changed", "the campaign's Page Kit config (SDK pin, analytics ids, store fields) changed"],
   ["campaign_config_unavailable", "the campaign's Page Kit config entry could not be read"],
   ["change_history_unavailable", "the rebuilds since the reviewed build were not kept"],
@@ -62,6 +62,34 @@ const unavailablePageChanges = new Map([
   ["build_manifest_unavailable", "no usable assembly manifest is available."],
 ]);
 
+// What an owed stage's change was read against, for a report that can disagree
+// with the last `record build` because it counts every rebuild since that
+// stage's own review.
+const shortBuild = (value) => String(value).replace(/^sha256:/, "").slice(0, 12);
+const stageNames = { polish: "Polish", qa: "QA" };
+function changeBasisLine(stage, record) {
+  const since = record?.change?.since_build_fingerprint;
+  if (!since) return null;
+  const at = /^\d{4}-\d{2}-\d{2}/.exec(String(record.reviewed_at ?? ""))?.[0];
+  return `- ${stageNames[stage]} change is read against the build it last checked (${code(shortBuild(since))}${at ? `, ${at}` : ""}), counting every rebuild since.`;
+}
+
+// Polish and QA read back along one chain of rebuilds, so when both have a
+// commerce rebuild behind a page-only edit it is the same one.
+function uncoveredRebuildLine(ci, stages) {
+  const behind = stages.filter((stage) => ci[stage].change?.commerce_rebuild?.latest_change_kind === "page_only");
+  if (!behind.length) return null;
+  const rebuild = ci[behind[0]].change.commerce_rebuild;
+  const at = /^\d{4}-\d{2}-\d{2}/.exec(String(rebuild.recorded_at ?? ""))?.[0];
+  const names = behind.map((stage) => stageNames[stage]).join(" and ");
+  return `- The latest change alone is page-only. ${names} still ${behind.length > 1 ? "owe" : "owes"} the full stage for an earlier rebuild${at ? ` recorded ${at}` : ""} (${code(shortBuild(rebuild.build_fingerprint))}) since that check.`;
+}
+
+function baselineLine(baseline) {
+  const at = /^\d{4}-\d{2}-\d{2}/.exec(String(baseline.accepted_at ?? ""))?.[0];
+  return `QA rests on a baseline ${text(baseline.accepted_by)} accepted${at ? ` on ${at}` : ""}, not a test. No purchase has been tested since.`;
+}
+
 const requiredStageReasons = new Map([
   ["stage_required_by_build", "the build requires this stage again"],
   ["stage_required_by_brief", "the brief requires this stage again"],
@@ -132,6 +160,12 @@ export function formatDoctorCi(result) {
   for (const stage of advisory) {
     lines.push(`- Advisory ${stage}: the change since its last review is page-only, so it is reported and not required.`);
   }
+  for (const stage of [...owed, ...advisory]) {
+    const basis = changeBasisLine(stage, ci[stage]);
+    if (basis) lines.push(basis);
+  }
+  const uncovered = uncoveredRebuildLine(ci, owed);
+  if (uncovered) lines.push(uncovered);
   // The pages changed since the builds the owed stages reviewed, which
   // record build keeps; without them, the drift from the assembly manifest.
   const sincePages = new Map();
@@ -168,6 +202,7 @@ export function formatDoctorCi(result) {
       lines.push("", "Remedy: rebuild, then run `campaigns-os record build --packet <packet>`, `campaigns-os polish capture --packet <packet> --base-url <served-current-build-url>` for the whole route, and `campaigns-os record polish --packet <packet> --evidence <polish-evidence.json>`, in that order. When QA is owed, run `campaigns-os qa run --packet <packet>` against that build.");
     }
   }
+  if (ci.qa.baseline) lines.push("", baselineLine(ci.qa.baseline));
   lines.push("", `Doctor inspection: ${(result.errors || []).length} error(s), ${(result.warnings || []).length} warning(s); CI exit status depends only on evidence debt.`);
   if (result.errors?.length) {
     lines.push(`Doctor errors: ${[...new Set(result.errors.map((issue) => issue.code))].map(code).join(", ")}.`);

package/src/evidence-debt.mjs

@@ -12,7 +12,7 @@ import {
 import { changeSince, classifyDrift } from "./change-scope.mjs";
 import { normalizePublicRouteSlug } from "./route-identity.mjs";
 import { isFileReadFailure } from "./cart-placeholders.mjs";
-import { polishReviewedBuild, qaExtendedBuildFingerprint, qaRecordedBuildFingerprint, qaRecordedForCurrentBuild } from "./stage-ledger.mjs";
+import { polishReviewedBuild, qaExtendedBuildFingerprint, qaRecordedBuildFingerprint, qaRecordedForCurrentBuild, qaRestsOnBaseline } from "./stage-ledger.mjs";
 
 export const EVIDENCE_DEBT_STATUSES = Object.freeze(["current", "owed", "unknown"]);
 
@@ -148,6 +148,9 @@ export function assessEvidenceDebt({ packet = null, packetPath = null, report =
   if (qa.status === "owed") {
     const extended = qaExtendedBuildFingerprint(report);
     qa.change = changeFor(extended || qaBuild);
+    // Only a completed QA dates its own review: a blocked full run reviewed
+    // nothing, and a blocked page-scoped run is read from the QA it extended.
+    if (extended && extended === qaBuild && fingerprint(qaRecord?.checked_at)) qa.reviewed_at = qaRecord.checked_at.trim();
     qa.scope = extended && qaRecord?.status !== "required" && qa.change.kind === "page_only" ? "pages" : "full";
     qa.owed_pages = qa.scope === "pages" ? qa.change.changed_pages : [];
   } else {
@@ -155,5 +158,10 @@ export function assessEvidenceDebt({ packet = null, packetPath = null, report =
     qa.scope = null;
     qa.owed_pages = [];
   }
+  const baseline = qaRestsOnBaseline(report);
+  if (baseline) {
+    const { accepted_by, accepted_at, reason: acceptedFor, build_fingerprint } = baseline;
+    qa.baseline = { accepted_by, accepted_at, reason: acceptedFor, build_fingerprint };
+  }
   return { polish, qa, changes };
 }

package/src/input-currency.mjs

@@ -16,8 +16,10 @@ import { isObject, optionalString, resolveFromFile } from "./cli-helpers.mjs";
 import { specMaterialHash } from "./spec-identity.mjs";
 
 // Every raw stage status the lifecycle writes. Any other value reads unknown.
-export const RECOGNIZED_STAGE_STATUSES = Object.freeze(["pending", "blocked", "required", "completed", "completed_with_warnings", "completed_partial", "skipped"]);
-const COMPLETED_STATUSES = Object.freeze(["completed", "completed_with_warnings", "completed_partial"]);
+export const RECOGNIZED_STAGE_STATUSES = Object.freeze(["pending", "blocked", "required", "completed", "completed_with_warnings", "completed_partial", "skipped", "baseline_accepted"]);
+// Read for currency, not for proof: a baseline carries input stamps, so a later
+// spec or brief change owes the stage again.
+const COMPLETED_STATUSES = Object.freeze(["completed", "completed_with_warnings", "completed_partial", "baseline_accepted"]);
 const NOT_APPLICABLE_STATUSES = Object.freeze(["pending", "blocked", "required", "skipped"]);
 const TERMINAL_EFFECTIVE_STATUSES = Object.freeze([...COMPLETED_STATUSES, "skipped"]);
 

package/src/input-refresh.mjs

@@ -63,7 +63,7 @@ const BRIEF_MAX_BYTES = 1024 * 1024;
 const BRIEF_MAX_DESIGN_AUTHORITY_ENTRIES = 512;
 const BRIEF_PROMPT_PREFIX = "BUILD_BRIEF_";
 const BRIEF_GATE_PREFIX = "build_brief.";
-const COMPLETED_STATUSES = Object.freeze(["completed", "completed_with_warnings", "completed_partial"]);
+const COMPLETED_STATUSES = Object.freeze(["completed", "completed_with_warnings", "completed_partial", "baseline_accepted"]);
 
 const isBriefBlocker = (entry) => typeof entry?.code === "string" && (entry.code.startsWith(BRIEF_PROMPT_PREFIX) || entry.code.startsWith(BRIEF_GATE_PREFIX));
 

package/src/invocation.mjs

@@ -65,12 +65,12 @@ const COMMANDS = frozen({
   theme: { subcommands: ["generate", "inspect", "waive"] },
   checkpoint: { subcommands: ["accept", "waive"] },
   polish: { subcommands: ["capture"] },
-  record: { subcommands: ["brief", "build", "deploy", "polish", "setup", "spec", "theme"] },
+  record: { subcommands: ["baseline", "brief", "build", "deploy", "polish", "setup", "spec", "theme"] },
   "validate-assembly-report": {},
   "install-agent-context": { dryRun: true },
   "install-skills": { dryRun: true },
   "page-kit": { subcommands: ["parity", "sync"] },
-  spec: { subcommands: ["derive"] },
+  spec: { subcommands: ["derive", "fetch"] },
   next: { subcommands: ["build", "deploy", "polish", "qa", "setup"] },
   qa: { subcommands: ["install-browser", "parity", "policy", "promote", "publish", "resolve", "run", "waive"] },
   findings: { subcommands: ["add", "export", "harvest", "list"] },
@@ -100,6 +100,7 @@ const SUBCOMMAND_OVERRIDES = frozen({
   "record polish": { dryRun: true },
   "record setup": { dryRun: true },
   "record spec": { dryRun: true },
+  "record baseline": { dryRun: true },
   "record theme": { dryRun: true },
   "qa run": { autoEnd: true },
   "run start": { sweepRoot: "session" },

package/src/orchestration-stage-contract.mjs

@@ -56,8 +56,10 @@ export function reportKeyForCliStage(cliStage) {
  * decided on its effective status (src/input-currency.mjs), which the `next`
  * picker and the Assembly Report's derived summary (src/stage-ledger.mjs)
  * read: a stage owed again is not done, whatever status it records.
+ * "baseline_accepted" is terminal without being completed: a named person
+ * accepted the build (`record baseline`), and nothing tested it.
  */
-export const STAGE_TERMINAL_STATUS_PREFIXES = Object.freeze(["completed", "skipped"]);
+export const STAGE_TERMINAL_STATUS_PREFIXES = Object.freeze(["completed", "skipped", "baseline_accepted"]);
 
 export function stageIsTerminal(status) {
   const normalized = String(status || "");

package/src/polish-gate.mjs

@@ -393,6 +393,16 @@ function evaluateStructuredPolishGate({ report, required = false, now = Date.now
   }
 
   const buildFingerprint = currentBuildFingerprint(report);
+  // A baseline reviewed nothing, so it grants no pass; it only stands for its
+  // own build. The stale check below handles it once the build has moved on.
+  if (report.stages?.polish?.status === "baseline_accepted" && normalizeString(report.stages.polish.source_build_fingerprint) === buildFingerprint) {
+    return {
+      status: "not_applicable",
+      code: "polish.baseline_accepted",
+      reason: "Polish was not run for this build: a named person accepted it as a baseline.",
+      build_fingerprint: buildFingerprint,
+    };
+  }
   const currentSourcePackageFingerprint = currentSourcePackageMaterialFingerprint(report);
   const assemblySourcePackageFingerprint = assemblySourcePackageMaterialFingerprint(report);
   const waiverAssessment = assessAssemblySourcePackageFreshnessWaivers(report, now);

package/src/qa-browser.mjs

@@ -1130,6 +1130,12 @@ async function runPageBrowserChecks(context, page, args, options = {}, policyLin
     assertions.push(...await templatePlaceholderTextAssertions(browserPage, page, options));
     assertions.push(...await templateDemoAssetAssertions(browserPage, page, options));
     assertions.push(...await pricingVisibilityAssertions(browserPage, page, options));
+    // Commercial parity compares these with calculated prices once the browser
+    // pass is over; a page never read here stays unresolved there.
+    if (options.renderedPackagePrices && !options.renderedPackagePrices.has(String(page.page_id))) {
+      const rendered = await readRenderedPackagePrices(browserPage);
+      if (rendered) options.renderedPackagePrices.set(String(page.page_id), rendered);
+    }
     observation.inspection_ms = elapsedMilliseconds(inspectionStarted);
     const debuggerStarted = performance.now();
     assertions.push(...await sdkDebuggerAssertions(context, page, args));
@@ -3104,6 +3110,45 @@ async function pricingVisibilityAssertions(browserPage, page, options = {}) {
   return [];
 }
 
+// Runs in the page. Every visible package.price node as the shopper reads it. The
+// SDK adds `display-visible` when it writes a node, and nothing else does, so a
+// node without it still holds the template's placeholder, whatever that says.
+// Same package scope as the SDK: the id in the path, then the nearest package id.
+// A price the page multiplies by a live quantity is not a unit price: it keeps no
+// text, so it stays unresolved instead of being compared.
+function collectRenderedPackagePrices() {
+  const claims = new Map();
+  for (const element of document.querySelectorAll('[data-next-display^="package."]')) {
+    const binding = (element.getAttribute("data-next-display") || "").trim();
+    const match = /^package\.(?:([1-9]\d*)\.)?price$/.exec(binding);
+    if (!match) continue;
+    const format = (element.getAttribute("data-next-format") || "currency").trim().toLowerCase();
+    if (format !== "currency" || element.closest("del, s, strike")) continue;
+    if (!element.checkVisibility({ checkVisibilityCSS: true })) continue;
+    let packageId = match[1] ? Number(match[1]) : null;
+    for (let current = element; packageId === null && current; current = current.parentElement) {
+      for (const attribute of ["data-next-package-id", "data-next-package", "data-package-id"]) {
+        const value = (current.getAttribute(attribute) || "").trim();
+        if (packageId === null && /^[1-9]\d*$/.test(value)) packageId = Number(value);
+      }
+    }
+    const filled = element.classList.contains("display-visible");
+    const multiplied = element.hasAttribute("data-next-multiply-quantity");
+    const text = filled && !multiplied ? element.textContent.replace(/\s+/g, " ").trim() : null;
+    claims.set(`${binding}|${packageId}|${filled}|${text}`, { binding, package_id: packageId, filled, text });
+  }
+  return [...claims.values()];
+}
+
+async function readRenderedPackagePrices(browserPage, { timeoutMs = DEFAULT_SETTLE_TIMEOUT_MS } = {}) {
+  await browserPage.waitForFunction(
+    `(${collectRenderedPackagePrices.toString()})().every((claim) => claim.filled)`,
+    null,
+    { timeout: timeoutMs },
+  ).catch(() => {});
+  return browserPage.evaluate(collectRenderedPackagePrices).catch(() => null);
+}
+
 // The SDK renders a bundle or upsell price through data-next-bundle-display as
 // well as data-next-display (#532). A contract surface that lists price rows
 // also counts that attribute; an empty list stays empty so a contract that
@@ -9028,6 +9073,7 @@ export const __qaBrowserTestHooks = Object.freeze({
   ASSET_FETCH_MAX_BYTES,
   paymentChromeResidueAssertion,
   pricingVisibilityAssertions,
+  readRenderedPackagePrices,
   upsellPriceVisibilityAssertion,
   checkoutPriceVisibilityAssertion,
   assessReceiptRendering,