@nextcommerce/campaigns-os 1.60.0 → 1.62.0

package/src/progress-node.mjs

@@ -97,7 +97,7 @@ export function projectProgressObservation({workspace,context,report,doctor,cont
 }
 function lock(dir,fn,{budgetMs=1500}={}) {
   const lockPath=join(dir,'.allocation-lock');
-  return withDirectoryLock(lockPath,fn,{budgetMs,unavailable:(error)=>Object.assign(new Error('progress.lock_unavailable'),{lockPath,code:error?.code,obstruction:error?.obstruction})});
+  return withDirectoryLock(lockPath,fn,{budgetMs,unavailable:(error)=>Object.assign(new Error('progress.lock_unavailable'),{lockPath,code:error?.code,obstruction:error?.obstruction,holderPid:error?.holderPid})});
 }
 export async function persistProgressObservation(observation,{dir,now=()=>new Date(),historyLimit=32}={}) {
   mkdirSync(dir,{recursive:true,mode:0o700});
@@ -165,7 +165,8 @@ export async function observeProgress(args,continuation,{qaResult=null,packageVe
     if(remit.state==='failed')warn('[campaigns-os] Progress delivery pending; the local observation is retained. Lifecycle result is unchanged.');
     return {...remit,snapshot_id:snapshot.snapshot_id,reused};
   } catch(error) {
-    if(error?.message==='progress.lock_unavailable'&&error.obstruction)warn(`[campaigns-os] Progress allocation lock path ${error.lockPath} is occupied by ${error.obstruction}; it is never removed automatically. Move it out of the way. Lifecycle result is unchanged.`);
+    if(error?.message==='progress.lock_unavailable'&&error.code==='ELOCKFORMAT')warn(`[campaigns-os] Progress allocation lock at ${error.lockPath} is held by process ${error.holderPid} of a different campaigns-os release; capture stops instead of waiting. Run one campaigns-os release against this target at a time. Lifecycle result is unchanged.`);
+    else if(error?.message==='progress.lock_unavailable'&&error.obstruction)warn(`[campaigns-os] Progress allocation lock path ${error.lockPath} is occupied by ${error.obstruction}; it is never removed automatically. Move it out of the way. Lifecycle result is unchanged.`);
     else if(error?.message==='progress.lock_unavailable')warn(`[campaigns-os] Progress allocation lock occupied${error.lockPath?` at ${error.lockPath}`:''}; wait for the current writer. If it stays occupied (an abandoned, ownerless or interrupted lock), stop all campaigns-os writers for this target, then remove that lock directory (docs/progress-snapshots.md). Lifecycle result is unchanged.`);
     else warn('[campaigns-os] Progress observation unavailable; lifecycle result is unchanged.');
     return {state:'failed',reason:'capture_unavailable'};

package/src/qa-analytics-correctness.mjs

@@ -114,13 +114,25 @@ export function assessAnalyticsInventory(capture = {}, contract = {}, options =
   if (providers.facebook && providers.facebook.enabled !== false) {
     const id = providers.facebook.pixelId;
     const present = inventoryHas(inventory, "meta", id);
+    // #686: page code replaced window.fbq, so in-page calls after that were
+    // not observed. Without a matching pixel request the row is unmeasured,
+    // not a clean absence.
+    const unmeasured = !present && capture.metaObserver === "disarmed";
     assertions.push(emit({
       id: "analytics-correctness:tag:meta",
       status: present ? STATUS.PASS : STATUS.FAIL,
       severity: SEVERITY.BLOCKER,
       expected: `Meta pixel ${id || ""} fires on the page`.trim(),
-      actual: present ? "present" : `absent (${(inventory.meta || []).length} meta pixel(s) fired, none matching)`,
-      evidence: { declared: id || null, observed_count: (inventory.meta || []).length },
+      actual: present
+        ? "present"
+        : unmeasured
+          ? `unmeasured: the page replaced window.fbq, so in-page pixel calls could not be observed (${(inventory.meta || []).length} meta pixel(s) seen, none matching)`
+          : `absent (${(inventory.meta || []).length} meta pixel(s) fired, none matching)`,
+      evidence: {
+        declared: id || null,
+        observed_count: (inventory.meta || []).length,
+        ...(unmeasured ? { reason: "fbq_observer_disarmed" } : {}),
+      },
     }));
   }
 

package/src/qa-analytics-parity.mjs

@@ -27,6 +27,7 @@
 
 import { SEVERITY, STATUS } from "./qa-verdict.mjs";
 import { redactUrlQuery } from "./qa-url-privacy.mjs";
+import { readVendorBeacon, VENDOR_KEYS, vendorBeaconFor } from "./qa-vendor-endpoints.mjs";
 
 // Data layers the SDK and legacy funnels push through. The SDK's GTMAdapter
 // mirrors every `dl_*` event to window.dataLayer AND window.ElevarDataLayer;
@@ -107,6 +108,53 @@ export function analyticsInitScript(layers = HOOKED_DATA_LAYERS) {
         set(next) { backing = wrap(name, next || []); },
       });
     }
+    // Meta pixel calls (#686). Headless Chromium can run fbq init/track without
+    // fbevents.js ever requesting facebook.com/tr, so the pixel is also observed
+    // in-page: a pixel id counts once it is initialised and a track call follows
+    // in the same document. Only the id and event name leave the page.
+    const metaInits = [];
+    // Mirrored into the in-page store as well, like record(), for pages where
+    // the binding could not attach.
+    store.metaCalls = [];
+    const metaFire = (id, ev) => {
+      const call = { id: String(id), ev: ev ? String(ev) : null };
+      store.metaCalls.push(call);
+      emit({ type: "meta_call", call, document: documentState });
+    };
+    const pixelId = (value) => (typeof value === "string" || typeof value === "number") && String(value) ? String(value) : null;
+    const recordFbq = (args) => {
+      try {
+        const method = String(args[0] || "");
+        // fbq('init', pixelId[, userData]): the pixel id is always args[1].
+        if (method === "init" && pixelId(args[1])) {
+          const id = pixelId(args[1]);
+          if (!metaInits.includes(id)) metaInits.push(id);
+        } else if (method === "track" || method === "trackCustom") {
+          for (const id of metaInits) metaFire(id, args[1]);
+        } else if ((method === "trackSingle" || method === "trackSingleCustom") && metaInits.includes(pixelId(args[1]))) {
+          metaFire(args[1], args[2]);
+        }
+      } catch (_) {}
+    };
+    const wrapFbq = (fn) => {
+      if (typeof fn !== "function" || fn.__nextQaWrapped || typeof Proxy !== "function") return fn;
+      // A Proxy keeps fbq's own properties (queue, callMethod, loaded) on the
+      // real function, so fbevents.js sees the object it installed.
+      return new Proxy(fn, {
+        apply(target, self, args) { recordFbq(args); return Reflect.apply(target, self, args); },
+        get(target, key, receiver) { return key === "__nextQaWrapped" ? true : Reflect.get(target, key, receiver); },
+      });
+    };
+    let fbqBacking = wrapFbq(window.fbq);
+    // The getter is marked so a read can tell this accessor from one page code
+    // installed, or from a deleted property.
+    const fbqGet = function () { return fbqBacking; };
+    Object.defineProperty(fbqGet, "__nextQaFbqAccessor", { value: true });
+    Object.defineProperty(window, "fbq", {
+      configurable: true,
+      get: fbqGet,
+      set(next) { fbqBacking = wrapFbq(next); },
+    });
   })();`;
 }
 
@@ -209,6 +257,18 @@ export async function attachAnalyticsCapture(page, options = {}) {
           }
           return;
         }
+        if (payload?.type === "meta_call") {
+          // An in-page fbq call is pixel inventory only. Its event name stays
+          // out of `params`, so it never counts as a Meta Purchase fire or
+          // supplies a CAPI dedup key; those still need the /tr request.
+          const id = payload.call?.id;
+          if (!id) return;
+          const document = payload.document
+            ? lookupDocument(payload.document, { fallbackUrl: sourceUrl, mainFrame })
+            : (mainFrame ? activeMainDocument : null) || lookupDocument({}, { fallbackUrl: sourceUrl, mainFrame });
+          tagFires.push({ kind: "meta", id: String(id), host: null, params: {}, source: "fbq", event: payload.call?.ev || null, document });
+          return;
+        }
         const entry = payload?.type === "event" ? payload.entry : payload;
         const attributed = attributeEvent(entry, { mainFrame, fallbackUrl: sourceUrl });
         if (attributed) accumulatedEvents.push(attributed);
@@ -221,6 +281,12 @@ export async function attachAnalyticsCapture(page, options = {}) {
     const url = typeof request.url === "function" ? request.url() : request.url;
     const fire = classifyTagFire(url, extraHosts);
     if (!fire) return;
+    // A listed vendor beacon can carry its id in the body (Snap, TikTok).
+    if (!fire.id) {
+      let body = null;
+      try { body = typeof request.postData === "function" ? request.postData() : null; } catch { /* no body */ }
+      fire.id = readVendorBeacon(url, body)?.ids[0] || null;
+    }
     let documentUrl = safePageUrl();
     try {
       let frame = typeof request.frame === "function" ? request.frame() : null;
@@ -243,6 +309,19 @@ export async function attachAnalyticsCapture(page, options = {}) {
     try {
       const raw = await page.evaluate(() => ({
         events: window.__nextQaAnalytics?.events || [],
+        metaCalls: window.__nextQaAnalytics?.metaCalls || [],
+        // Whether in-page fbq calls were still observable when read: page code
+        // that redefines window.fbq removes the wrapper (#686).
+        // Deleting or redefining the property disarms it too; "absent" means
+        // the QA accessor is still installed and no pixel was ever set.
+        metaObserver: (() => {
+          if (!window.__nextQaAnalytics) return null;
+          const descriptor = Object.getOwnPropertyDescriptor(window, "fbq");
+          if (!descriptor || !descriptor.get || descriptor.get.__nextQaFbqAccessor !== true) return "disarmed";
+          const fbq = window.fbq;
+          if (fbq === undefined || fbq === null) return "absent";
+          return fbq.__nextQaWrapped === true ? "armed" : "disarmed";
+        })(),
         document: window.__nextQaAnalytics?.document || { url: String(location.href || "") },
       }));
       snapshot = Array.isArray(raw) ? { events: raw, document: null } : (raw || snapshot);
@@ -272,18 +351,28 @@ export async function attachAnalyticsCapture(page, options = {}) {
     const journeyEvents = bindingAttached
       ? [...accumulatedEvents, ...snapshotEvents]
       : snapshotEvents;
+    // Without the binding, in-page fbq calls come only from this document's
+    // store; with it, they are already in tagFires.
+    const snapshotMetaFires = !bindingAttached && Array.isArray(snapshot.metaCalls)
+      ? snapshot.metaCalls.filter((call) => call?.id).map((call) => ({
+          kind: "meta", id: String(call.id), host: null, params: {}, source: "fbq", event: call.ev || null, document: snapshotDocument,
+        }))
+      : [];
+    const journeyTagFires = [...tagFires, ...snapshotMetaFires];
     const currentEvents = journeyEvents.filter(
       (entry) => entry.document?.mainFrame === true
         && entry.document.generation === currentDocument.generation,
     );
-    const currentTagFires = tagFires.filter(
+    const currentTagFires = journeyTagFires.filter(
       (fire) => fire.document?.mainFrame === true
         && fire.document.generation === currentDocument.generation,
     );
+    const metaObserver = typeof snapshot.metaObserver === "string" ? snapshot.metaObserver : null;
     return {
-      journey: normalizeCapture({ events: journeyEvents, tagFires }),
+      journey: { ...normalizeCapture({ events: journeyEvents, tagFires: journeyTagFires }), metaObserver },
       currentDocument: {
         ...normalizeCapture({ events: currentEvents, tagFires: currentTagFires }),
+        metaObserver,
         document: publicDocument(currentDocument),
       },
     };
@@ -338,6 +427,14 @@ export function classifyTagFire(urlString, extraHostSubstrings = []) {
   const fire = (kind, id) => ({ kind, id: id ? String(id) : null, host, params });
   const subs = [...DEFAULT_EXTRA_ANALYTICS_HOST_SUBSTRINGS, ...extraHostSubstrings];
 
+  // A listed vendor beacon (qa-vendor-endpoints.mjs) is that vendor's fire,
+  // answered locally or not, with the id from its query or path when it has one.
+  const beacon = vendorBeaconFor(url.href);
+  if (beacon) {
+    const pathId = beacon.idPath ? path.match(beacon.idPath)?.[1] : null;
+    return fire(beacon.vendor, pathId || (beacon.id && !beacon.id.includes(".") ? params[beacon.id] : null) || null);
+  }
+
   if (hostMatches(host, "googletagmanager.com")) {
     const id = params.id || null;
     if (id && /^GTM-/i.test(id)) return fire("gtm", id);
@@ -457,13 +554,17 @@ export function normalizeCapture({ events = [], tagFires = [] } = {}) {
   }
 
   const inventory = { gtm: [], ga4: [], google_ads: [], meta: [], tiktok: [], everflow: [], other: [] };
+  for (const vendor of VENDOR_KEYS) inventory[vendor] ||= [];
+  // Pixel ids seen on a facebook.com request, apart from in-page fbq calls.
+  const metaRequestIds = [];
   let metaPurchaseEventId = null;
   let metaPurchaseFired = false;
   let ga4PurchaseFired = false;
   for (const fire of tagFires) {
     if (!fire || !inventory[fire.kind]) continue;
     if (fire.id && !inventory[fire.kind].includes(fire.id)) inventory[fire.kind].push(fire.id);
-    if (fire.kind === "meta") {
+    if (fire.kind === "meta" && fire.source !== "fbq") {
+      if (fire.id && !metaRequestIds.includes(fire.id)) metaRequestIds.push(fire.id);
       const ev = fire.params?.ev || fire.params?.event;
       if (ev && String(ev).toLowerCase() === "purchase") {
         metaPurchaseFired = true;
@@ -483,6 +584,7 @@ export function normalizeCapture({ events = [], tagFires = [] } = {}) {
     purchase: purchase ? { present: true, ...purchase } : { present: false },
     purchasesByEvent,
     inventory,
+    metaRequestIds,
     metaPurchaseEventId,
     // Purchase can fire from any of three sources (dataLayer event, Meta pixel,
     // GA4) — campaigns that block the SDK event and fire Meta/GA4 manually still
@@ -680,8 +782,11 @@ export function diffAnalyticsParity(baseline, candidate, options = {}) {
 
     // 5. Meta CAPI dedup — candidate's Meta Purchase fire carries an eventID,
     //    consistent with the order id so client + server events dedup.
-    const baselineHasMeta = (b.inventory?.meta || []).length > 0;
-    const candidateHasMeta = (c.inventory?.meta || []).length > 0;
+    //    Keyed on pixel requests: an in-page fbq call with no /tr request has
+    //    no eventID to compare (#686).
+    const metaRequests = (cap) => cap.metaRequestIds || cap.inventory?.meta || [];
+    const baselineHasMeta = metaRequests(b).length > 0;
+    const candidateHasMeta = metaRequests(c).length > 0;
     if (baselineHasMeta || candidateHasMeta) {
       const eid = c.metaPurchaseEventId;
       const consistent = eid && cp.transactionId && String(eid) === String(cp.transactionId);
@@ -698,7 +803,7 @@ export function diffAnalyticsParity(baseline, candidate, options = {}) {
 
   // 6. Carried-over tag regression — any baseline container/pixel absent on the
   //    candidate is a WARN (likely attribution regression; human confirms drop).
-  const kinds = ["gtm", "ga4", "google_ads", "meta", "tiktok", "everflow", "other"];
+  const kinds = [...new Set(["gtm", "ga4", "google_ads", "meta", "tiktok", "everflow", "other", ...VENDOR_KEYS])];
   for (const kind of kinds) {
     const baselineIds = (b.inventory?.[kind]) || [];
     const candidateIds = new Set((c.inventory?.[kind]) || []);

package/src/qa-browser.mjs

@@ -19,6 +19,7 @@ import { redactPersisted, redactUrlQueriesInText, redactUrlQuery } from "./qa-ur
 import { TRACKING_ADDED_BOUND_MS, TRACKING_OBSERVATION, createTrackingRun, trackingQaAssertion } from "./qa-tracking-params.mjs";
 import { CONTENT_PARAM_LIMITS, runContentParamChecks } from "./qa-content-params.mjs";
 import { createPolicyLinkBudget, hasPolicyLinkFields, readPageAnchors, runPolicyLinkChecks } from "./qa-policy-links.mjs";
+import { vendorBeaconLedgerFor, withVendorBeaconRouting } from "./qa-vendor-beacons.mjs";
 import {
   canonicalHttpUrl,
   commonTestOrderPaths,
@@ -462,6 +463,8 @@ async function dispatchTestOrderPlans({ context, plans, checkoutPage, args = {},
       if (displayParity) assertions.push(displayParity);
       const totalParity = orderTotalParityAssertion(pageForPlan, identifier, result.order);
       if (totalParity) assertions.push(totalParity);
+      const currencyMatch = orderCurrencyAssertion(pageForPlan, identifier, result.order, args);
+      if (currencyMatch) assertions.push(currencyMatch);
       const renderedReceiptAssertion = receiptRenderingAssertion(pageForPlan, identifier, result.order);
       if (renderedReceiptAssertion) assertions.push(renderedReceiptAssertion);
       const dataLayerAssertion = purchaseDataLayerAssertion(pageForPlan, identifier, result.order);
@@ -4900,9 +4903,13 @@ export const QA_RUN_CURRENCY = Symbol("qa run --currency");
 // checkout opened directly. Campaign Cart keeps a URL currency in session
 // storage for the rest of the tab's session, so later loads in the tab are
 // the plain URL; the receipt reload in recovery is not a path load at all.
-function pathCurrencyLoad(args) {
+function runCurrency(args) {
   const code = args?.[QA_RUN_CURRENCY];
-  let pending = typeof code === "string" && /^[A-Z]{3}$/.test(code) ? code : null;
+  return typeof code === "string" && /^[A-Z]{3}$/.test(code) ? code : null;
+}
+
+function pathCurrencyLoad(args) {
+  let pending = runCurrency(args);
   return (url) => {
     if (!pending) return url;
     const entered = withQueryParam(url, "currency", pending);
@@ -6638,6 +6645,31 @@ function orderTotalParityAssertion(page, planIdentifier, order) {
   });
 }
 
+// `qa run --currency <code>`: a created order must have been placed in the
+// run currency. Campaign Cart falls back to the default currency when the
+// requested one is not available, so an order recorded in any other currency
+// blocks, and so does a verified order whose currency was not recorded. No run
+// currency, or no order body read at all (the order's own row already says
+// why), gives no row.
+function orderCurrencyAssertion(page, planIdentifier, order, args) {
+  const expected = runCurrency(args);
+  if (!expected) return null;
+  const recorded = stringArg(order?.verification?.currency);
+  if (!recorded && order?.verification?.verified !== true) return null;
+  const actual = recorded ? recorded.toUpperCase() : null;
+  const ok = actual === expected;
+  return assertion({
+    id: `browser-order-currency:${planIdentifier}`,
+    family: "browser-test-order",
+    page,
+    status: ok ? STATUS.PASS : STATUS.FAIL,
+    severity: ok ? undefined : SEVERITY.BLOCKER,
+    expected: `the order is placed in the run currency ${expected}`,
+    actual: actual ? `order placed in ${actual}` : "the order's currency was not recorded",
+    evidence: { requested: expected, order_currency: actual },
+  });
+}
+
 // --- What a failed attempt did to the store ----------------------------------
 //
 // This replaces the old `shouldRetryTestOrder` boolean, which asked only whether
@@ -8873,8 +8905,11 @@ function trim(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
-function launchChromium(args) {
-  return launchPackageChromium({ headed: args.headed, onMissing: qaBrowserMissing });
+// Every browser QA leg launches here, so on a test-order run every context it
+// opens answers the vendor beacon endpoints locally (qa-vendor-beacons.mjs).
+async function launchChromium(args) {
+  const browser = await launchPackageChromium({ headed: args.headed, onMissing: qaBrowserMissing });
+  return withVendorBeaconRouting(browser, vendorBeaconLedgerFor(args));
 }
 
 function qaBrowserMissing(kind, error) {
@@ -8893,6 +8928,7 @@ function qaBrowserMissing(kind, error) {
 }
 
 export const __qaBrowserTestHooks = Object.freeze({
+  orderCurrencyAssertion,
   qaBrowserMissing,
   PRIMARY_CTA_SELECTOR,
   COUPON_INPUT_SELECTORS,

package/src/qa-commercial-parity.mjs

@@ -379,7 +379,9 @@ export async function mapConcurrent(values, limit, operation) {
   return results;
 }
 
-export function planCommercialParity(spec, { maxScenarios = COMMERCIAL_QA_LIMITS.max_scenarios } = {}) {
+// `currency` is the run's currency (`qa run --currency`): every calculate
+// request asks for it instead of the Map's campaign currency.
+export function planCommercialParity(spec, { maxScenarios = COMMERCIAL_QA_LIMITS.max_scenarios, currency = null } = {}) {
   const limit = positiveLimit(maxScenarios, COMMERCIAL_QA_LIMITS.max_scenarios);
   const pages = commercialSpecPages(spec, { maxPages: limit + 1 });
   const plan = [];
@@ -391,7 +393,7 @@ export function planCommercialParity(spec, { maxScenarios = COMMERCIAL_QA_LIMITS
       break;
     }
     try {
-      plan.push(...planScenarios(page, spec, { maxScenarios: remaining }));
+      plan.push(...planScenarios(page, spec, { maxScenarios: remaining, currency }));
     } catch (error) {
       if (!(error instanceof CommercialJourneyLimitError)) throw error;
       overflow = true;
@@ -502,6 +504,9 @@ function compactReport(report, journey, plan, executed, issues, observedClaims,
     extracted_voucher_claims: report.extracted_voucher_claims,
     compared_voucher_claims: report.compared_voucher_claims,
     unresolved_voucher_claims: report.unresolved_voucher_claims,
+    ...(present(report.unresolved_money_claims_reason)
+      ? { unresolved_money_claims_reason: report.unresolved_money_claims_reason }
+      : {}),
     serialized_assertion_count: report.serialized_assertion_count,
     omitted_assertion_count: report.omitted_assertion_count,
     recurring_claim_absences: array(report.recurring_claim_absences),
@@ -581,6 +586,31 @@ export function unavailableCommercialReport(code, { status = "not_run" } = {}) {
   };
 }
 
+// One blocker row per currency the calculate endpoint answered in other than
+// the run's: expected totals were asked for in `currency` and came back priced
+// in another one. Answered codes are compared and named upper-cased, so `usd`
+// and `USD` are one row. The rows are few (one per answered currency) and sit
+// outside the assertion budget, so a full budget never hides the blocker.
+function runCurrencyMismatchAssertions(journey, currency) {
+  const requested = String(currency).toUpperCase();
+  const answered = new Set();
+  array(journey?.warnings).forEach((warning) => {
+    if (warning?.type !== "currency_mismatch" || String(warning.requested).toUpperCase() !== requested) return;
+    const actual = String(warning.actual).toUpperCase();
+    if (actual !== requested) answered.add(actual);
+  });
+  return [...answered].map((actual) => ({
+    id: `commercial-currency:${requested}:${encodeURIComponent(actual)}`,
+    family: "pricing",
+    page: "campaign",
+    status: "fail",
+    severity: "blocker",
+    expected: `expected totals calculated in the run currency ${requested}`,
+    actual: `the calculate endpoint priced in ${actual}`,
+    evidence: { code: "currency_mismatch", requested, actual },
+  }));
+}
+
 /**
  * Run the portable commercial planner against the public proxy contract and
  * serialize proven mismatches into ordinary QA assertions.
@@ -592,6 +622,7 @@ export async function runCommercialParity({
   limits: limitOverrides = {},
   planning = null,
   maxAssertions = Number.POSITIVE_INFINITY,
+  currency = null,
 } = {}) {
   const limits = {
     ...COMMERCIAL_QA_LIMITS,
@@ -603,6 +634,7 @@ export async function runCommercialParity({
   const planningSpec = resolved?.rawSpec || resolved?.spec || {};
   const commercialPlanning = planning || planCommercialParity(planningSpec, {
     maxScenarios: limits.max_scenarios,
+    currency,
   });
   const plan = commercialPlanning.plan;
   const scenarioOverflow = commercialPlanning.overflow || plan.length > limits.max_scenarios;
@@ -654,9 +686,24 @@ export async function runCommercialParity({
   const parityJourney = scenarioOverflow
     ? withScenarioOverflowPages(journey, commercialPlanning.pages)
     : journey;
+  // Under a run currency, a calculate response in another currency means the
+  // campaign does not price in it: a blocker, and the comparison below is
+  // against totals in the wrong currency, so the proof is incomplete. Without
+  // one, the journey's currency_mismatch warning stays where it is.
+  const currencyAssertions = present(currency) ? runCurrencyMismatchAssertions(journey, currency) : [];
+  currencyAssertions.forEach(() => issues.push({ code: "calculate_currency_mismatch" }));
+  // Captures read the page's source HTML, whose bound prices are the authored
+  // fallback text in the Map's campaign currency (the SDK replaces them at
+  // runtime). Under a run currency the Map does not name, those amounts cannot
+  // be compared with totals in the run currency: they stay unresolved, with
+  // the reason recorded, instead of reading as mismatches.
+  const sourceCurrency = planningSpec?.campaign?.currency ?? planningSpec?.currency;
+  const sourceNotInRunCurrency = present(currency)
+    && String(sourceCurrency ?? "").toUpperCase() !== String(currency).toUpperCase();
   const parity = createCommercialParityReport(captures, parityJourney, {
     maxAssertions,
     countsOnly: aggregateClaimOverflow,
+    ...(sourceNotInRunCurrency ? { unresolvedMoneyClaims: "static_source_not_in_run_currency" } : {}),
   });
   // Subscription packages a page renders with no recurring claim read for
   // them: incomplete evidence (an issue), and a warning naming the package.
@@ -669,7 +716,7 @@ export async function runCommercialParity({
   });
   parity.recurring_claim_absences = absences;
   return {
-    assertions: [...parity.assertions, ...absentAssertions],
+    assertions: [...currencyAssertions, ...parity.assertions, ...absentAssertions],
     commercial: compactReport(
       parity,
       parityJourney,