@nextcommerce/campaigns-os 1.55.0 → 1.57.0

package/src/doctor/checks.mjs

@@ -93,6 +93,7 @@ import { FIGMA_EXPORT_FILE_CODES, SOURCE_PROVENANCE_SCOPE, evaluateSourceProvena
 import { validateCampaignBuildBriefArtifact } from "../build-brief.mjs";
 import { briefFileUnusable, deriveInputCurrency, wellFormedBriefMaterial } from "../input-currency.mjs";
 import { ASSEMBLY_REPORT_STAGE_KEYS, stageIsTerminal } from "../orchestration-stage-contract.mjs";
+import { assemblyReportStagesWithEvidence } from "../design-source-publication.mjs";
 import {
   assemblySourcePackageFingerprintMissing,
   assessAssemblySourcePackageFreshnessWaivers,
@@ -108,7 +109,7 @@ import { evaluatePageKitSdkVersion, PAGE_KIT_SDK_VERSION_SCOPE } from "../page-k
 // `npm run build:spec` (tsc -> campaign-spec/dist) so the package runs on the
 // node engine in package.json without type-stripping. build runs on `prepare`,
 // so a fresh install (including the git-ref consumer) always has dist.
-import { isReleasedSdkVersion, normalize as normalizeCampaignSpec, runRules, specOnlyRules } from "../../campaign-spec/dist/index.js";
+import { CHECKOUT_FLOW_PAGE_TYPES, checkoutPathFrom, isReleasedSdkVersion, normalize as normalizeCampaignSpec, runRules, specOnlyRules, upgradeCampaignSpec } from "../../campaign-spec/dist/index.js";
 import { cmd, asInvocation } from "../install-invocation.mjs";
 import { specHashesMatch, specMaterialHash } from "../spec-identity.mjs";
 import {
@@ -237,8 +238,12 @@ const US_MARKET_COPY_PATTERNS = [
 const HARDCODED_CURRENCY_REGEX = /\$\s?\d[\d,]*(?:\.\d+)?(?:\/[A-Za-z]+)?/g;
 const HARDCODED_PHONE_REGEX = /\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g;
 
+// Pages read through here see the v5 vocabulary: a v4 spec's `checkout → checkout`
+// chain is retyped `checkout_step` on read (campaigns-os#641), so every doctor
+// check asks "is this the page that takes payment" of `type === "checkout"`.
 function normalizeFunnels(spec) {
-  if (Array.isArray(spec?.funnels)) return spec.funnels;
+  const upgraded = upgradeCampaignSpec(spec);
+  if (Array.isArray(upgraded?.funnels)) return upgraded.funnels;
   if (Array.isArray(spec?.funnel_pages)) {
     return [{ id: "default", weight: 100, pages: spec.funnel_pages }];
   }
@@ -542,6 +547,11 @@ function validatePacket(packet, packetPath, errors, warnings, ready, derived, bu
     addIssue(errors, "packet.type", "Build Packet must be a JSON object.");
     return;
   }
+  Object.defineProperty(derived, "page_kit_entry_mappings", {
+    value: Object.fromEntries((packet.source_html?.pages || [])
+      .filter((page) => page?.page_kit?.target_path).map((page) => [page.page_id, page])),
+    configurable: true,
+  });
   const synthesizedBuiltSite = isSynthesizedBuiltSitePacket(packet);
   if (packet.schema_version !== PACKET_SCHEMA) addIssue(errors, "schema_version", `Expected ${PACKET_SCHEMA}.`);
   else ready.push(`Build Packet schema ${PACKET_SCHEMA}`);
@@ -1201,17 +1211,20 @@ function paymentLogoForcedOn(html, method) {
 // unless the checkout page passes show_<method>=false.
 export const STARTER_TEMPLATE_DEFAULT_ON_PAYMENT_METHODS = Object.freeze(["paypal", "klarna", "apple_pay", "google_pay"]);
 
-// Built checkout pages on disk for the spec's active checkout pages: the
-// rendered _site/<slug>/<route>/index.html files that exist. Empty before a
-// build (or when the spec declares no checkout page), which is the pre-build
-// state the spec-only advisory covers.
+// Built checkout-flow pages on disk for the spec's active select, checkout_step
+// and checkout pages: the rendered _site/<slug>/<route>/index.html files that
+// exist. Steps and select pages are included on purpose: they carry express
+// payment buttons upstream of the Checkout (campaigns-os#641), and an
+// unsupported method rendered there ships just the same. Empty before a build
+// (or when the spec declares no checkout page), which is the pre-build state
+// the spec-only advisory covers.
 function builtCheckoutPagesForSpec(spec, packet, derived = {}) {
   const targetRepo = derived?.target_repo;
   const publicRouteSlug = normalizePublicRouteSlug(packet?.campaign?.public_route_slug);
   if (!targetRepo || !publicRouteSlug) return [];
   const built = [];
   for (const page of activeSpecPages(spec)) {
-    if (String(page?.type || page?.page_type || "").toLowerCase().trim() !== "checkout") continue;
+    if (!CHECKOUT_FLOW_PAGE_TYPES.includes(String(page?.type || page?.page_type || "").toLowerCase().trim())) continue;
     const path = builtHtmlPathForPage(targetRepo, publicRouteSlug, page, derived);
     if (!path || !existsSync(path) || !statSync(path).isFile()) continue;
     built.push({ page_id: page.id, path, file: relative(targetRepo, path).split(sep).join("/") });
@@ -2815,7 +2828,7 @@ function bumpDisplaysPresent(block, displays) {
   return displays.some((name) => new RegExp(`data-next-toggle-display\\s*=\\s*["']${name}["']`, "i").test(block));
 }
 
-const CHECKOUT_BUMP_PAGE_TYPES = new Set(["checkout", "select"]);
+const CHECKOUT_BUMP_PAGE_TYPES = new Set(CHECKOUT_FLOW_PAGE_TYPES);
 
 export function validateBuiltBumpPricing(content, builtPath, targetRepo, page, issueTarget) {
   const type = String(page?.type || page?.page_type || "").toLowerCase().trim();
@@ -3000,6 +3013,11 @@ function validateBuiltCommerceRefs(content, builtPath, targetRepo, page, spec, i
 
 function builtHtmlPathForPage(targetRepo, publicRouteSlug, page, derived = {}) {
   if (!targetRepo || !publicRouteSlug) return null;
+  const entryRoute = entryPageKitServingRoute(targetRepo, publicRouteSlug, page, {
+    targetOutputDir: derived?.target_output_dir,
+    mapping: derived?.page_kit_entry_mappings?.[page?.id],
+  });
+  if (entryRoute) return join(targetRepo, "_site", publicRouteSlug, ...(entryRoute.route ? [entryRoute.route] : []), "index.html");
   const sourcePermalink = sourcePermalinkForPage(derived?.target_output_dir, publicRouteSlug, page);
   const route = sourcePermalink || runtimeRelativeRouteForSpecValue(publicRouteForPage(page), publicRouteSlug);
   if (!route) return join(targetRepo, "_site", publicRouteSlug, "index.html");
@@ -3007,6 +3025,63 @@ function builtHtmlPathForPage(targetRepo, publicRouteSlug, page, derived = {}) {
   return clean ? join(targetRepo, "_site", publicRouteSlug, clean, "index.html") : join(targetRepo, "_site", publicRouteSlug, "index.html");
 }
 
+export function isRootRoutedEntryPage(page, publicRouteSlug) {
+  return Boolean(page?.is_entry) && runtimeRelativeRouteForSpecValue(publicRouteForPage(page), publicRouteSlug) === "";
+}
+
+// An explicit permalink belongs to this entry's Page Kit source file. It wins
+// even when an older build left output at the filename-derived route.
+export function entryPageKitServingRoute(targetRepo, publicRouteSlug, page, { targetOutputDir = null, mapping = null } = {}) {
+  if (!targetRepo || !publicRouteSlug || !isRootRoutedEntryPage(page, publicRouteSlug)) return null;
+  const permalink = entrySourcePermalink(targetOutputDir, publicRouteSlug, page, mapping);
+  if (permalink !== null) return { route: permalink, source: "permalink" };
+  const root = join(targetRepo, "_site", publicRouteSlug, "index.html");
+  if (existsSync(root) && statSync(root).isFile()) return { route: "", source: "root" };
+  const fileRoute = entryPageKitFileRoute(targetRepo, publicRouteSlug, page, { targetOutputDir, mapping });
+  return fileRoute ? { route: `${fileRoute}/`, source: "file" } : { route: "", source: "declared" };
+}
+
+function entrySourcePermalink(targetOutputDir, publicRouteSlug, page, mapping) {
+  if (!targetOutputDir || !existsSync(targetOutputDir) || !statSync(targetOutputDir).isDirectory()) return null;
+  const names = mapping?.page_kit?.target_path
+    ? [mapping.page_kit.target_path]
+    : [...new Set([page.id, page.type].filter(isNonEmptyString).map((name) => `${name}.html`))];
+  const routes = names
+    .filter((name) => /^[a-zA-Z0-9][a-zA-Z0-9_-]*\.html$/.test(name))
+    .map((name) => join(targetOutputDir, name))
+    .filter((path) => existsSync(path) && statSync(path).isFile())
+    .map((path) => extractFrontmatterValue(readFileSync(path, "utf8"), "permalink"))
+    .filter(isNonEmptyString)
+    .map((value) => stripPublicRoutePrefix(normalizePageKitRoute(value), publicRouteSlug));
+  return routes[0] ?? null;
+}
+
+// Page Kit serves a page file without a permalink at its basename route.
+// Only the recorded target file (or the family's own materialised stock file)
+// may identify an entry fallback; an unrelated built index is not evidence.
+export function entryPageKitFileRoute(targetRepo, publicRouteSlug, page, { targetOutputDir = null, mapping = null } = {}) {
+  if (!targetRepo || !publicRouteSlug || !isRootRoutedEntryPage(page, publicRouteSlug)) return null;
+  if (entrySourcePermalink(targetOutputDir, publicRouteSlug, page, mapping) !== null) return null;
+  const root = join(targetRepo, "_site", publicRouteSlug, "index.html");
+  if (existsSync(root) && statSync(root).isFile()) return null;
+  let names;
+  if (mapping?.page_kit?.target_path) {
+    names = [mapping.page_kit.target_path];
+  } else {
+    if (!targetOutputDir) return null;
+    names = [...new Set([page.id, page.type].filter(isNonEmptyString).map((name) => `${name}.html`))];
+  }
+  const routes = names
+    .filter((name) => /^[a-zA-Z0-9][a-zA-Z0-9_-]*\.html$/.test(name) && name !== "index.html")
+    .filter((name) => mapping?.page_kit || (existsSync(join(targetOutputDir, name)) && statSync(join(targetOutputDir, name)).isFile()))
+    .map((name) => name.slice(0, -".html".length))
+    .filter((route) => {
+      const built = join(targetRepo, "_site", publicRouteSlug, route, "index.html");
+      return existsSync(built) && statSync(built).isFile();
+    });
+  return routes[0] ?? null;
+}
+
 function sourcePermalinkForPage(targetOutputDir, publicRouteSlug, page) {
   if (!targetOutputDir || !existsSync(targetOutputDir) || !statSync(targetOutputDir).isDirectory()) return null;
 
@@ -3446,7 +3521,7 @@ function validateSpecPublicRoutes(spec, errors, ready) {
 }
 
 function pageRole(type) {
-  if (["checkout", "upsell", "downsell", "thankyou", "receipt", "select"].includes(type)) return "runtime";
+  if (["checkout", "checkout_step", "upsell", "downsell", "thankyou", "receipt", "select"].includes(type)) return "runtime";
   return "visual";
 }
 
@@ -3550,6 +3625,7 @@ function templateStockDecision(buildState, pageId) {
 function validateSourceCoverage(packet, packetPath, spec, errors, warnings, ready, derived = {}, buildState = {}) {
   const pages = packet.source_html?.pages || [];
   const publicRouteSlug = normalizePublicRouteSlug(packet?.campaign?.public_route_slug);
+  const routeRoot = campaignRouteRoot(packet);
   const materialisedTemplateStock = [];
   const sourceRoot = resolveFromFile(packetPath, packet.source_html?.root);
   validateSourceHtmlManifestAtRoot(sourceRoot, {
@@ -3577,6 +3653,20 @@ function validateSourceCoverage(packet, packetPath, spec, errors, warnings, read
     }
     mappedIds.add(page.page_id);
     const specPage = activeById.get(page.page_id);
+    const entryRoute = specPage
+      ? entryPageKitServingRoute(derived.target_repo, publicRouteSlug, specPage, {
+        targetOutputDir: derived.target_output_dir,
+        mapping: page,
+      })
+      : null;
+    const builtRoute = entryRoute ? entryRoute.route : specPage ? publicRouteForPage(specPage) : null;
+    const rootOutput = entryRoute?.route ? join(derived.target_repo, "_site", publicRouteSlug, "index.html") : null;
+    if (rootOutput && (entryRoute.source === "file" || entryRoute.source === "permalink")
+      && !(existsSync(rootOutput) && statSync(rootOutput).isFile())) {
+      const emittedRoute = `${routeRoot}${entryRoute.route}`;
+      const pageKitRoot = `/${normalizePublicRouteSlug(publicRouteSlug)}/`;
+      addIssue(warnings, "entry_route.unserved", `CampaignSpec entry page "${specPage.id}" is routed to ${routeRoot}, but Page Kit emitted it at ${emittedRoute} and nothing serves ${routeRoot}. Add a redirect from ${routeRoot} to ${emittedRoute}, or set \`permalink: ${pageKitRoot}\` (the campaign root as Page Kit emits it) on the entry page.`, { page_id: specPage.id, root_route: routeRoot, emitted_route: emittedRoute });
+    }
     if (!activeIds.has(page.page_id)) {
       addIssue(warnings, "source_html.pages.extra", `Source mapping "${page.page_id}" is not an active CampaignSpec page.`);
     }
@@ -3611,7 +3701,7 @@ function validateSourceCoverage(packet, packetPath, spec, errors, warnings, read
             page_id: specPage.id,
             type: specPage.type || "page",
             role: pageRole(specPage.type),
-            route: publicRouteForPage(specPage),
+            route: builtRoute,
             source_path: page.path,
           });
         }
@@ -3627,7 +3717,7 @@ function validateSourceCoverage(packet, packetPath, spec, errors, warnings, read
           page_id: specPage.id,
           type: specPage.type || "page",
           role: pageRole(specPage.type),
-          route: publicRouteForPage(specPage),
+          route: builtRoute,
           source_path: null,
           template_stock: true,
           template_family: family,
@@ -3956,6 +4046,98 @@ function packageRefsFromEntries(entries) {
     .filter((value) => value !== undefined && value !== null && String(value).trim().length > 0)
     .map((value) => String(value));
 }
+
+function supportsCheckoutVariantSlots(agentContract) {
+  const required = frontmatterList(agentContract, "requiredWhenCloning");
+  return required.includes("variant_slots[].id") && required.includes("variant_slots[].quantity");
+}
+
+function selectableVariantMatrixCount(packages) {
+  const selectable = Array.isArray(packages)
+    ? packages.filter((pkg) => pkg && pkg.is_order_bump !== true && pkg.is_upsell !== true)
+    : [];
+  const quantityRows = selectable.filter((pkg) => String(pkg.qty ?? "").trim());
+  if (quantityRows.length <= 1) return 0;
+  const attributeIdentity = (pkg) => {
+    if (!Array.isArray(pkg.variant_attributes) || pkg.variant_attributes.length === 0) return null;
+    const attributes = pkg.variant_attributes.map((attribute) => {
+      const value = String(attribute?.value ?? "").trim();
+      if (!value) return null;
+      return [String(attribute?.code || attribute?.name || "").trim(), value];
+    });
+    return attributes.every(Boolean) ? JSON.stringify(attributes.sort(([a], [b]) => a.localeCompare(b))) : null;
+  };
+  const textIdentity = (key) => (pkg) => {
+    const value = pkg[key];
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+  };
+  for (const identity of [attributeIdentity, textIdentity("product_variant_name")]) {
+    const values = quantityRows.map(identity);
+    if (!values.every(Boolean)) continue;
+    const quantitiesByVariant = new Map();
+    for (const [index, value] of values.entries()) {
+      const qty = String(quantityRows[index].qty).trim();
+      if (!quantitiesByVariant.has(value)) quantitiesByVariant.set(value, new Set());
+      quantitiesByVariant.get(value).add(qty);
+    }
+    return quantitiesByVariant.size > 1 && [...quantitiesByVariant.values()].some((quantities) => quantities.size > 1)
+      ? quantitiesByVariant.size
+      : 0;
+  }
+  return 0;
+}
+
+function warnCheckoutPackageFamilyFit(specPages, family, catalog, warnings, report) {
+  const selectedContract = catalog.families?.[family]?.agentContract;
+  if (
+    !selectedContract ||
+    !isCertifiedTemplateFamily(family, catalog) ||
+    !frontmatterList(selectedContract, "requiredWhenCloning").includes("packages.main_package") ||
+    supportsCheckoutVariantSlots(selectedContract)
+  ) return;
+  const fittingFamilies = [...certifiedTemplateFamilies(catalog)]
+    .filter((candidate) => supportsCheckoutVariantSlots(catalog.families[candidate]?.agentContract))
+    .sort();
+  const checkoutPages = specPages.filter((page) => CHECKOUT_FLOW_PAGE_TYPES.includes(page.type));
+  const byFunnel = new Map();
+  for (const page of checkoutPages) {
+    if (!byFunnel.has(page.funnel_id)) byFunnel.set(page.funnel_id, []);
+    byFunnel.get(page.funnel_id).push(page);
+  }
+  const paths = new Map();
+  for (const page of checkoutPages) {
+    const pages = byFunnel.get(page.funnel_id);
+    const path = checkoutPathFrom(pages, page) || [page];
+    const end = path[path.length - 1];
+    const key = `${page.funnel_id}:${end.id}`;
+    if (!paths.has(key)) paths.set(key, []);
+    const pathPages = paths.get(key);
+    for (const candidate of path) {
+      if (!pathPages.includes(candidate)) pathPages.push(candidate);
+    }
+  }
+  const hasStageEvidence = assemblyReportStagesWithEvidence(report).length > 0;
+  const multiStep = [...paths.values()].some((pathPages) =>
+    pathPages.some((candidate) => candidate.type === "checkout_step" || candidate.type === "select"));
+  for (const pathPages of paths.values()) {
+    const page = pathPages.find((candidate) => selectableVariantMatrixCount(candidate.packages) > 1);
+    if (!page) continue;
+    const variantCount = selectableVariantMatrixCount(page.packages);
+    const shapeMatches = fittingFamilies.filter((candidate) => Boolean(catalog.families[candidate]?.canonicalSurfaces?.selectStep) === multiStep);
+    // The catalog has no base-family field; its family-name prefix is the shared-base convention.
+    const baseMatches = shapeMatches.filter((candidate) => candidate.startsWith(`${family}-`));
+    const ranked = [...baseMatches, ...shapeMatches.filter((candidate) => !baseMatches.includes(candidate))];
+    const action = hasStageEvidence
+      ? "The template family is a build-time decision; changing it requires re-running intake with --force (destructive; clears recorded stage evidence)."
+      : "The family is chosen at intake with --template-family.";
+    addIssue(
+      warnings,
+      "template_contract.checkout_package_fit",
+      `Checkout path through page "${page.id}" has ${variantCount} variants, some offered at several quantities, but template family "${family}" has no configurable variant_slots[] checkout surface. ${ranked.length ? `Families that can present it: ${ranked.join(", ")}.` : "No certified family has a matching configurable variant-slot checkout surface."} ${action}`,
+      { page_id: page.id, funnel_id: page.funnel_id, template_family: family, distinct_product_variants: variantCount, fitting_families: ranked },
+    );
+  }
+}
 function offerRefsFromEntries(entries) {
   if (!Array.isArray(entries)) return [];
   return entries
@@ -4140,6 +4322,7 @@ export function validateCommerceCatalog(packet, packetPath, spec, errors, warnin
 
     // ADR-003 step 2: template-contract checks ported from the private doctor.
     const specPages = activeSpecPages(spec);
+    warnCheckoutPackageFamilyFit(specPages, family, catalog, warnings, buildState.report);
 
     const mismatchedFamilies = specPages.filter(
       (page) => isNonEmptyString(page.sdk_hints?.template_family) && page.sdk_hints.template_family !== family
@@ -4153,7 +4336,7 @@ export function validateCommerceCatalog(packet, packetPath, spec, errors, warnin
     }
 
     const checkoutPackageRefs = specPages
-      .filter((page) => page.type === "checkout" || page.type === "select")
+      .filter((page) => CHECKOUT_FLOW_PAGE_TYPES.includes(page.type))
       .flatMap((page) => packageRefsFromEntries(page.packages));
     if (familyAutomatable && contractMentions(contract, /\b(packages\.main_package|single_offer\.package_id|variant_slots)\b/) && checkoutPackageRefs.length === 0) {
       addIssue(
@@ -4268,7 +4451,7 @@ export function validateExitPopContract(contract, spec, family, warnings, ready,
   const exitPop = contract?.exit_pop;
   if (!exitPop || !spec) return;
   const hasGovernedOfferSurface = activeSpecPages(spec).some((page) => (
-    page?.type === "checkout" && (page?.exit_intent?.enabled === true || page?.promo_code_input?.enabled === true)
+    CHECKOUT_FLOW_PAGE_TYPES.includes(page?.type) && (page?.exit_intent?.enabled === true || page?.promo_code_input?.enabled === true)
   ));
   if (hasGovernedOfferSurface) {
     ready.push(`${family} exit-pop/promo-code behavior is governed by CampaignSpec offer-surface fields`);

package/src/doctor/inspect.mjs

@@ -34,6 +34,7 @@ import {
   readJsonIfExists,
   relFromDir,
   isLocalAbsolutePath,
+  portableArtifactPaths,
   addIssue,
 } from "../cli-helpers.mjs";
 import {
@@ -187,18 +188,19 @@ export function doctorCommand(args, { runDoctor = doctorPacket, liveCampaign = u
     commitAssemblyReport(workspace, (report) => recordDoctorStageOutcome(report, result, {
       command: `campaigns-os ${DOCTOR_PRODUCER}`,
       doctorOutPath: workspace.doctorOutPath,
+      targetRepo: workspace.targetRepo,
     }), { stage: "doctor", command: DOCTOR_PRODUCER, refreshDoctor: () => result });
   }
   return result;
 }
 
-function recordDoctorStageOutcome(report, result, { command, doctorOutPath }) {
+function recordDoctorStageOutcome(report, result, { command, doctorOutPath, targetRepo }) {
   return recordProducerStageOutcome(report, {
     stage: "doctor",
     disposition: result.ok ? (result.warnings?.length ? "ready_with_warnings" : "ready") : "blocked",
     timestamp: result.generated_at,
     command,
-    outputs: [doctorOutPath],
+    outputs: portableArtifactPaths([doctorOutPath], targetRepo),
     blockers: (result.errors || []).map((issue) => issue?.message).filter(isNonEmptyString),
     warnings: (result.warnings || []).map((issue) => issue?.message).filter(isNonEmptyString),
   });

package/src/doctor/next-step.mjs

@@ -1,6 +1,6 @@
 // The next step doctor recommends, and the gate issues `next` reads from doctor.
 import { campaignIdentitiesMatch } from "../spec-source-identity.mjs";
-import { polishCarriedForwardForLadder } from "../local-preview-policy.mjs";
+import { NO_CAPTURABLE_ROUTES_CODE, hostedTemplateNeedsUsablePreview, polishCarriedForwardForLadder, polishGateCanCarryPreview } from "../local-preview-policy.mjs";
 import { resolve } from "node:path";
 import { orderPathDepthDriftText } from "../proof-policy.mjs";
 import { anyAssemblyReportStageBlocked, qaRecordedBuildFingerprint, qaRecordedForCurrentBuild } from "../stage-ledger.mjs";
@@ -19,6 +19,7 @@ import {
 import { currentBuildFingerprint, evaluatePolishGate } from "../polish-gate.mjs";
 import { effectiveStageStatus, effectiveStatusIsTerminal } from "../input-currency.mjs";
 import { cmd } from "../install-invocation.mjs";
+import { shellToken } from "../shell-token.mjs";
 import { isObject, isNonEmptyString, optionalString, resolveFromFile, addIssue, filesystemPathsMatch } from "../cli-helpers.mjs";
 import { orderPathDepthDrift } from "./checks.mjs";
 
@@ -412,7 +413,7 @@ export function assessPurchaseProofCoverage({ packet = null, report = null } = {
   };
 }
 
-function pickNextStage(report, { errors = [], derived = null }, prepareBuildGate, purchaseProof = null) {
+function pickNextStage(report, { errors = [], derived = null }, prepareBuildGate, purchaseProof = null, packet = null) {
   const polishGate = derived?.polish_gate || evaluatePolishGate({ report });
   const polishCheckpointGate = derived?.polish_checkpoint_gate || null;
   // prepare-build is the earliest lifecycle prerequisite. Surface its
@@ -476,6 +477,12 @@ function pickNextStage(report, { errors = [], derived = null }, prepareBuildGate
     // A first local preview may carry missing Polish forward. A theme waiver
     // or prior capture makes the recorded Polish stage owed again.
     if (cliStage === "polish" && polishCarriedForwardForLadder(report, polishGate)) continue;
+    // A hosted all-template preview has no hosted deploy recorder. The
+    // recorded preview URL satisfies this one deploy handoff while the
+    // carried-forward gate identifies the exact preview-only shape.
+    if (cliStage === "deploy" && packet?.deploy?.preview_url
+      && polishGate?.carried_forward?.policy === "hosted_template_preview"
+      && polishCheckpointGate?.carried_forward?.policy === "hosted_template_preview") continue;
     const reportKey = reportKeyForCliStage(cliStage);
     const stage = report.stages[reportKey];
     if (!stage) {
@@ -517,9 +524,13 @@ function pickNextStage(report, { errors = [], derived = null }, prepareBuildGate
     }
   }
 
+  const hostedPreview = Boolean(packet?.deploy?.preview_url && polishGate?.carried_forward?.policy === "hosted_template_preview");
   return {
     stage: "done",
-    reason: "All stages are in a terminal status (completed / completed_with_warnings / skipped). Pipeline is complete.",
+    outcome: hostedPreview ? "hosted_preview_satisfies_deploy" : "standard_closeout",
+    reason: hostedPreview
+      ? "The recorded hosted preview satisfies deploy, and QA is terminal for the current build. Pipeline is complete."
+      : "All stages are in a terminal status (completed / completed_with_warnings / skipped). Pipeline is complete.",
   };
 }
 
@@ -577,7 +588,7 @@ export const DOCTOR_NEXT_STAGE_OWNERS = NEXT_STAGE_OWNERS;
 // The code -> action strings doctor prints under `Next:`. They describe the
 // repairs the findings ask for and are independent of which stage the picker
 // names, so they survive the picker consolidation unchanged.
-function doctorNextActions(errors, warnings, derived, { polishBlocked, polishGate, polishCheckpointGate, packetRef = derived.packet_path || "<packet>" }) {
+function doctorNextActions(errors, warnings, derived, { polishBlocked, polishGate, polishCheckpointGate, packet = null, packetRef = derived.packet_path || "<packet>" }) {
   const codes = new Set([...errors, ...warnings].map((issue) => issue.code));
   const onlyPolishErrors = doctorErrorsAreOnlyPolishGate(errors);
   const actions = [];
@@ -633,11 +644,17 @@ function doctorNextActions(errors, warnings, derived, { polishBlocked, polishGat
     actions.push(`Target campaign output directory is missing; run ${cmd("next")} setup --packet ${packetRef} before build.`);
   }
   if (polishBlocked) {
-    if (polishGate.status === "blocked") {
+    const needsHostedPreview = hostedTemplateNeedsUsablePreview(packet, polishCheckpointGate);
+    if (needsHostedPreview) {
+      actions.push(`Every mapped page is template stock and needs a hosted preview URL that differs from the production URL. Run ${cmd("qa")} policy set --packet ${packetRef} --preview-url <url>, then run ${cmd("next")} --packet ${packetRef}.`);
+    }
+    if (polishGate.status === "blocked" && (!needsHostedPreview || !polishGateCanCarryPreview(polishGate))) {
       actions.push(`${polishGate.reason} Run next-campaigns-polish and record structured evidence before deploy/QA handoff.`);
     }
-    if (polishCheckpointGate?.status === "blocked") {
-      actions.push(`${polishCheckpointGate.reason} Run ${cmd("polish")} capture before marking Polish complete.`);
+    if (polishCheckpointGate?.status === "blocked" && !needsHostedPreview) {
+      actions.push(polishCheckpointGate.code === NO_CAPTURABLE_ROUTES_CODE
+        ? `${polishCheckpointGate.reason} ${polishCheckpointGate.required_actions?.[0]?.description || "Map a design route and rerun intake before QA."}`
+        : `${polishCheckpointGate.reason} Run ${cmd("polish")} capture before marking Polish complete.`);
     }
   }
   return actions;
@@ -656,7 +673,7 @@ function buildNextStep(errors, warnings, derived, report = null, packet = null,
     && (polishGate.status === "blocked" || polishCheckpointGate?.status === "blocked");
   const codes = new Set([...errors, ...warnings].map((issue) => issue.code));
   const purchaseProof = report ? assessPurchaseProofCoverage({ packet, report }) : null;
-  const picked = pickNextStage(report, { errors, derived }, prepareBuildGate, purchaseProof);
+  const picked = pickNextStage(report, { errors, derived }, prepareBuildGate, purchaseProof, packet);
   // The picker's vocabulary and this table must not drift apart: a stage the
   // table does not know would otherwise be relabelled as an operator step and
   // sliced into the whole ladder. Fail loudly instead.
@@ -665,8 +682,8 @@ function buildNextStep(errors, warnings, derived, report = null, packet = null,
   }
   // An explicit --context / --report is carried into every recommended
   // command, so a recovery reads the same artifacts the recommendation did.
-  const packetRef = `${derived.packet_path || "<packet>"}${sidecarArgs}`;
-  const actions = doctorNextActions(errors, warnings, derived, { polishBlocked, polishGate, polishCheckpointGate, packetRef });
+  const packetRef = `${derived.packet_path ? shellToken(derived.packet_path) : "<packet>"}${sidecarArgs}`;
+  const actions = doctorNextActions(errors, warnings, derived, { polishBlocked, polishGate, polishCheckpointGate, packet, packetRef });
   const deployStatus = String(report?.stages?.deploy?.status || "");
   const deploySatisfied = ["completed", "completed_with_warnings", "ready_with_exceptions"].some((prefix) => deployStatus.startsWith(prefix))
     || Boolean(deployUrlFromReportOutputs(report));
@@ -713,7 +730,9 @@ function buildNextStep(errors, warnings, derived, report = null, packet = null,
       ? `${cmd("next")} --packet ${packetRef}`
       : `${cmd("next")} ${picked.stage} --packet ${packetRef}`;
   const fallbackAction = picked.stage === "done"
-    ? `All stages are recorded as terminal; run ${cmd("next")} to confirm the closeout actions.`
+    ? (picked.outcome === "hosted_preview_satisfies_deploy"
+      ? `${picked.reason} Run ${cmd("next")} to confirm the closeout actions.`
+      : `All stages are recorded as terminal; run ${cmd("next")} to confirm the closeout actions.`)
     : `Run ${command}.`;
   if (picked.stage === "done") {
     actions.unshift(fallbackAction);
@@ -733,6 +752,7 @@ function buildNextStep(errors, warnings, derived, report = null, packet = null,
     default_skill: owners.default_skill,
     command,
     reason: picked.reason,
+    ...(picked.outcome ? { outcome: picked.outcome } : {}),
     actions: actions.length ? actions : [fallbackAction],
     // Gate-blocked stages stay listed even when the recommended stage is
     // runnable (a Design Source Package change after assembly names build,

package/src/doctor-sidecar.mjs

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { portableArtifactPaths } from "./cli-helpers.mjs";
 
 export const DOCTOR_SIDECAR_REL_PATH = ".campaign-runtime/doctor-output.json";
 export const DOCTOR_SIDECAR_SCHEMA = "campaigns-os-doctor-output/v0";
@@ -61,8 +62,9 @@ export function stampDoctorProducer(doctor, command) {
 // through this (or through `stampDoctorProducer` when its own transactional
 // writer must do the rename), so `generated_by` cannot be skipped by one of
 // them the way #327's cause labels once were.
-export function writeDoctorSidecar(path, doctor, { command } = {}) {
-  writeJsonAtomic(path, stampDoctorProducer(doctor, command));
+export function writeDoctorSidecar(path, doctor, { command, targetRepo = null } = {}) {
+  const stamped = stampDoctorProducer(doctor, command);
+  writeJsonAtomic(path, targetRepo ? portableArtifactPaths(stamped, targetRepo) : stamped);
   return path;
 }
 
@@ -89,7 +91,7 @@ export function markDoctorSidecarStale(targetBaseDir, { command = null, reason =
     stale_reason: reason
       || "A later command changed doctor inputs after this snapshot was written. Re-run campaigns-os doctor (or campaigns-os next) for current state.",
   };
-  writeJsonAtomic(path, stamped);
+  writeJsonAtomic(path, portableArtifactPaths(stamped, targetBaseDir));
   return path;
 }
 

package/src/gate-actions.mjs

@@ -68,10 +68,30 @@ export const HIDDEN_EAGER_MEDIA_ACTIONS = Object.freeze({
     id: "polish.hidden_eager_media.map_design_route",
     kind: "manual",
     command: null,
-    description: "Every mapped page is template stock, so polish capture has nothing to measure. Map at least one page to its design source HTML (source_html.pages[].path) and rerun intake, or prove the campaign on the local preview (deploy.target local-serve served from localhost), where this missing evidence is carried forward as a warning.",
+    description: "Every mapped page is template stock, so there is no design route to measure. Map at least one page to its design source HTML (source_html.pages[].path) and rerun intake, or use a local or hosted preview for QA with the missing evidence carried forward as a warning.",
   }),
 });
 
+export function qaRunCommand(packetPath, url, bumpCart = null) {
+  return `${invocationPrefixFor(PACKAGE_ROOT)} qa run --packet ${packetPath ? shellToken(packetPath) : "<packet>"} --base-url ${url === "<preview-url>" ? url : shellToken(url)} --browser --test-order common${bumpCart ? ` --cart ${shellToken(bumpCart.cart)}` : ""}`;
+}
+
+export function hostedTemplateQaAction(previewUrl) {
+  return {
+    id: "polish.hidden_eager_media.hosted_preview_qa",
+    kind: "command",
+    command: qaRunCommand(null, previewUrl),
+    description: "Run QA against the packet's hosted preview URL; missing Polish evidence remains a warning.",
+  };
+}
+
+export const HOSTED_TEMPLATE_PREVIEW_URL_ACTION = Object.freeze({
+  id: "polish.hidden_eager_media.set_hosted_preview_url",
+  kind: "command",
+  command: "campaigns-os qa policy set --packet <packet> --preview-url <url>",
+  description: "Record a hosted preview URL that differs from the production URL with qa policy set, then run next again; missing Polish evidence can be carried forward on that preview.",
+});
+
 const PACKET_PLACEHOLDER = "--packet <packet>";
 
 // The placeholder becomes the packet this run read, shell-quoted, so the

package/src/input-refresh.mjs

@@ -26,7 +26,7 @@ import {
   loadCampaignBuildBriefFile,
 } from "./build-brief.mjs";
 import { resolveCampaignWorkspace, targetRepoFor } from "./campaign-workspace.mjs";
-import { isObject, optionalString, relFromDir, resolveFromFile } from "./cli-helpers.mjs";
+import { isObject, optionalString, portableArtifactPaths, relFromDir, resolveFromFile } from "./cli-helpers.mjs";
 import { writeJsonAtomic } from "./doctor-sidecar.mjs";
 import { activeSpecPages, specIdentityMismatch } from "./doctor/checks.mjs";
 import {
@@ -475,9 +475,9 @@ function saveBriefUnderLock({ packetPath, explicitBrief, sidecars, lockedTarget,
     if (!dryRun) {
       // Intake's publication order, the report last: a failure between files
       // leaves the report bound to the old material, which reads as owed.
-      writeJsonAtomic(packetPath, nextPacket);
-      writeJsonAtomic(normalizedPath, buildBrief.artifact);
-      writeJsonAtomic(contextPath, saved.nextContext);
+      writeJsonAtomic(packetPath, portableArtifactPaths(nextPacket, targetRepo, { artifactPath: packetPath }));
+      writeJsonAtomic(normalizedPath, portableArtifactPaths(buildBrief.artifact, targetRepo, { artifactPath: normalizedPath }));
+      writeJsonAtomic(contextPath, portableArtifactPaths(saved.nextContext, targetRepo, { artifactPath: contextPath }));
       commitAssemblyReport(workspace, () => nextReport, {
         command: "record brief",
         staleReason: "The Campaign Build Brief was saved after this doctor snapshot. Re-run doctor (or next) for current state.",
@@ -674,8 +674,8 @@ function refreshSpecUnderLock({ packetPath, sidecars, lockedTarget, dryRun, time
     if (!dryRun) {
       // Intake's publication order, the report last: a failure between files
       // leaves the report bound to the old spec material, which reads as owed.
-      if (briefWritten) writeJsonAtomic(normalizedPath, brief.buildBrief.artifact);
-      writeJsonAtomic(contextPath, nextContext);
+      if (briefWritten) writeJsonAtomic(normalizedPath, portableArtifactPaths(brief.buildBrief.artifact, targetRepo, { artifactPath: normalizedPath }));
+      writeJsonAtomic(contextPath, portableArtifactPaths(nextContext, targetRepo, { artifactPath: contextPath }));
       commitAssemblyReport(workspace, () => nextReport, {
         command: "record spec",
         staleReason: "The CampaignSpec was bound with record spec after this doctor snapshot. Re-run doctor (or next) for current state.",