@nextcommerce/campaigns-os 1.50.0 → 1.53.0

package/src/cli.mjs

@@ -20,6 +20,7 @@ import {
 import { homedir } from "node:os";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { shellToken } from "./shell-token.mjs";
+import { declaredOrderBumps, declaredSelectorTiers } from "./commercial-journey.mjs";
 import { diagnosticExport, diagnosticTextLines } from "./diagnostic.mjs";
 import { observeProgress, PROGRESS_OBSERVATION } from "./progress-node.mjs";
 import { HIDDEN_EAGER_MEDIA_ACTIONS, requiredActionText, substitutePacket } from "./gate-actions.mjs";
@@ -75,7 +76,10 @@ import {
   isWrapperPolicy,
 } from "./adapter-decision-contract.mjs";
 import { markDoctorSidecarStale, writeDoctorSidecar, writeJsonAtomic } from "./doctor-sidecar.mjs";
-import { campaignSidecarPaths, resolveCampaignWorkspace, targetRepoFor } from "./campaign-workspace.mjs";
+import { QcAcceptRefusal, buildQcHandoff, parseQcResultRef, planQcAccepts, projectQcAccept, qcAcceptAttribution, qcHandoffTextLines } from "./qc-accept.mjs";
+import { loadQcRederivers } from "./qc-check-registry.mjs";
+import { fingerprint12, readCurrentQcResults } from "./qc-results.mjs";
+import { campaignSidecarPaths, explicitReportPath, resolveCampaignWorkspace, targetRepoFor } from "./campaign-workspace.mjs";
 import { canonicalPath, sameFile } from "./fs-identity.mjs";
 import { DEFAULT_PROXY_BASE, fetchSpecByMapId } from "./spec-fetch.mjs";
 import { writeMapSdkPin } from "./map-pin-writeback.mjs";
@@ -116,9 +120,11 @@ import {
   SOURCE_HTML_MANIFEST_REL_PATH,
 } from "./source-html-manifest.mjs";
 import { crawlSourceAssetPaths } from "./source-asset-crawl.mjs";
+import { summarizeCampaignBrief } from "./brief-summary.mjs";
 import {
   THEME_POLICIES,
   inspectBrandTheme,
+  themeIssueForReport,
   writeThemeArtifacts,
 } from "./brand-theme.mjs";
 import {
@@ -144,6 +150,7 @@ import {
   LOCAL_PROOF_BUILD_ENVIRONMENT_SCOPE,
   LOCAL_PROOF_NEVER_EDIT_RULE,
   LOCAL_PROOF_PARITY_COMMAND,
+  LOCAL_PROOF_RECORD_BUILD_COMMAND,
   LOCAL_PROOF_PARITY_FIELD,
   LOCAL_PROOF_PARITY_SCOPE,
   recordedBuildEnvironment,
@@ -168,6 +175,8 @@ import {
   createCampaignBuildBriefArtifact,
   inferBuildBriefPath,
 } from "./build-brief.mjs";
+import { briefIntakeBindings, currentPacketInputs, inputRefreshCommands, inputStamps, stageWriteInputs } from "./input-currency.mjs";
+import { prepareBuildStageStatus, priorBriefInputsForIntake } from "./input-refresh.mjs";
 import {
   DESIGN_SOURCE_PACKAGE_REL_PATH,
 } from "./design-source-package.mjs";
@@ -194,7 +203,7 @@ import {
   capturePolishPageLoad,
   createPolishCaptureBinding,
   evaluateRecordedHiddenEagerMediaCheckpoint,
-  mergePolishPageLoadEvidence,
+  mergePolishCaptureEvidence,
   planPolishCapture,
 } from "./polish-node.mjs";
 import { HIDDEN_EAGER_MEDIA_SCOPE, POLISH_CAPTURE_PROBLEM_CODES } from "./polish-page-load.mjs";
@@ -317,12 +326,15 @@ Usage:
   campaigns-os theme generate --packet <campaign-runtime.build.json> [--context <json>] [--out-dir <dir>] [--force] [--json]
   campaigns-os theme waive --packet <campaign-runtime.build.json> --reason "<why>" --waived-by "<named human>" [--expires-at <ISO>] [--report <json>] [--dry-run] [--json]   # record an explicit theme-gate waiver on the assembly report; placeholders such as "operator" are refused. --dry-run validates the same way and prints the waiver it would write, without touching the report
   campaigns-os checkpoint waive --packet <campaign-runtime.build.json> --gate <checkpoint-id> [--page <page_id>] --reason "<why>" --waived-by "<named human>" [--expires-at <ISO>] [--review-condition "<trigger>"] [--report <json>] [--dry-run] [--json]   # one bound is required; registered gates: page_kit.store_profile, page_kit.sdk_version, polish.hidden_eager_media, built_output.upsell_selector_scope, source_html.producer_provenance (per page: --page <page_id> is required, for a Figma-typed page whose approved source is hand-written HTML). --dry-run runs every check (named human, bounds, registered and waivable gate) and prints the waiver it would write, without touching the report
+  campaigns-os checkpoint accept --packet <campaign-runtime.build.json> --result <result_id>@<fingerprint12> [--result ...] --reason "<the operator's reason>" --accepted-by "<named human>" [--expires-at <ISO>] [--review-condition "<trigger>"] [--report <json>] [--dry-run] [--json]   # record the operator's accept of a measured QC warning, as the QC handoff of next prints it; changes no readiness and lapses when the measured state or the build changes. --dry-run runs every check and prints the accepts it would record, without touching the report
   campaigns-os page-kit sync --packet <campaign-runtime.build.json> [--dry-run] [--json]   # write the CampaignSpec's Store Profile fields (campaign.store_*) and SDK pin (global_config.sdk_version, runtime.sdk_version alias) into the target's _data/campaigns.json entry for the packet's route, printing a field-by-field diff; the recovery for a doctor blocked on page_kit.store_profile / page_kit.sdk_version after a fresh scaffold. Writes only those ten fields, only from usable spec values (a bad pin, a non-http URL, a non-tel: phone URI or the demo value itself is reported as not synced, status PARTIAL); exit 2 when the entry or the spec is missing, or the spec identifies another campaign.
   campaigns-os spec derive --packet <campaign-runtime.build.json> [--dry-run] [--json] [--report <json>] [--from-store <subdomain> [--store-token-source env:<VAR>]] [--write-map] [--proxy-base <url>]   # write the fields the target repo already states into the packet's local CampaignSpec (spec.local_path): the SDK pin from _data/campaigns.json[<route>].sdk_version (global_config.sdk_version, and the runtime.sdk_version alias when declared), each page's page_url from the page tree under src/<route>/ (filename or permalink), and the analytics ids the entry carries (gtm_id -> analytics.providers.gtm.containerId, fb_pixel_id -> analytics.providers.facebook.pixelId); prints a field-by-field before -> after diff and writes nothing else. Repo-derived fields only and no network by default; --from-store <subdomain> (the <store> of <store>.29next.store) also reads through campaigns-os login gateway credentials (--store-token-source env:<VAR> explicitly selects the warned break-glass Admin path; a token never goes on the command line) and writes the nine campaign.store_* Store Profile fields: store_name and store_url (primary domain) and store_phone/store_phone_tel from GET /store/, and store_terms/privacy/contact/returns/shipping as https://<primary domain>/<slug>/ from the one storefront page (GET /pages/) whose slug or title names each policy; an empty store field, no page or several never empties the spec's value. A field the repo or store cannot state (a scaffold's seeded pin, an unbound page, an empty or malformed id, an active page_kit.sdk_version waiver, an empty store field, an unbound policy page) is reported as not derived, status PARTIAL; exit 2 when the packet, the spec or the target entry is missing, the spec identifies another campaign, or the store cannot be read (credential missing, 401/403, no such store, unreachable). --write-map also records the derived pin into the saved Map's Build hints (Campaign Cart SDK version) through the proxy Worker (PUT /api/maps/<spec.map_id> under X-Campaign-Key, the packet's Campaigns API key, with the Map's spec_hash as the X-Spec-Hash precondition): written when the Map declares no pin or one behind the repo, unchanged when equal, refused (warning, exit 0) when the Map pin is ahead or cannot be ordered, failed (error, exit 2) when the key is missing or mismatched, the Map is gone, was saved in between, or the proxy refuses the body; the write is recorded on the Assembly Report evidence[] and in the result's map object. --proxy-base overrides the canonical proxy (https, or a loopback host over http); --dry-run reads the Map and reports would_write without a PUT.
   campaigns-os page-kit parity --packet <campaign-runtime.build.json> [--report <json>] [--json]   # local proof mode (deploy.target local-serve): render the current source in development and production through the target's page-kit into temp dirs, assert the served _site/ is the current development render and that production differs from it only in environment-gated output (same page set, same route slugs, same Campaign Cart pin and next-api-key); records stages.assembly.evidence.local_proof.production_parity, which doctor reads as local_proof.production_parity. Exit 2 on a non-gated difference.
   campaigns-os polish capture --packet <campaign-runtime.build.json> --base-url <url> [--report <json>] [--headed] [--auth-cookie <cookie>] [--json]
+  campaigns-os record brief --packet <campaign-runtime.build.json> [--brief <yaml|json>] [--context <json>] [--report <json>] [--dry-run] [--json]
+  campaigns-os record spec --packet <campaign-runtime.build.json> [--context <json>] [--report <json>] [--dry-run] [--json]
   campaigns-os record setup --packet <campaign-runtime.build.json> [--context <json>] [--report <json>] [--dry-run] [--json]   # record setup complete once the campaign output directory exists: Build Context scaffold.required=false and stages.setup completed, validated against their schemas before either is written
-  campaigns-os record build --packet <campaign-runtime.build.json> [--context <json>] [--report <json>] [--dry-run] [--json]   # after page-kit build: stages.assembly completed with build_fingerprint = doctor's derived.build_output_fingerprint.value (and the Design Source Package material fingerprint when the report has one); stages.polish becomes required unless its evidence is bound to this exact output
+  campaigns-os record build --packet <campaign-runtime.build.json> [--build-environment <development|production>] [--context <json>] [--report <json>] [--dry-run] [--json]   # after page-kit build (--build-environment records stages.assembly.evidence.build_environment; local proof mode records development): stages.assembly completed with build_fingerprint = doctor's derived.build_output_fingerprint.value (and the Design Source Package material fingerprint when the report has one); stages.polish becomes required unless its evidence is bound to this exact output
   campaigns-os record polish --packet <campaign-runtime.build.json> --evidence <polish-evidence.json> [--context <json>] [--report <json>] [--dry-run] [--json]   # after polish capture: stages.polish from the file's status (completed, completed_with_warnings, blocked with blockers, or skipped with skip_reason), evidence and optional repair_loop_defect, bound to doctor's current fingerprint; a completed status is refused, writing nothing, unless the polish gate doctor evaluates would pass. --dry-run runs every check and writes nothing
   campaigns-os record theme --packet <campaign-runtime.build.json> [--context <json>] [--report <json>] [--dry-run] [--json]   # after the brand layer is linked and build is recorded: report.theme becomes applied with load_order after-next-core, css_path, commerce_pages and per-page evidence, only when each built commerce page that loads next-core.css loads brand-theme.css (or checkout-brand.css) after it and at least one does; a page loading neither is left out as the design's own markup; refused, writing nothing, otherwise. --dry-run runs every check and writes nothing
   campaigns-os record deploy --packet <campaign-runtime.build.json> --base-url <served url> [--context <json>] [--report <json>] [--dry-run] [--json]   # a local preview (deploy.target local-serve) after polish is recorded: GETs every built page under the loopback URL (the campaign route root), then records deploy.preview_url on the packet and stages.deploy completed with the URL in outputs; refused, writing nothing, when the URL is not loopback or not the route root, a page does not answer 2xx, the build changed since it was recorded, or the theme gate is blocked. --dry-run runs every check, the requests included, and writes nothing
@@ -458,9 +470,12 @@ function closestCommand(input) {
 // invocation policy: src/invocation.mjs owns it and main() only hands over the
 // mechanisms. The raw argv rides along for the handlers that must see it
 // (authentication, and the two raw-token validators).
-export async function main(argv, { authentication } = {}) {
+// `qcStandIns` is the in-process QC stand-in override the QC tests pass
+// (src/qc-test-factories.mjs). The bin entry point never passes it, and no
+// flag, environment variable or file can supply one.
+export async function main(argv, { authentication, qcStandIns } = {}) {
   return runInvocation(parseArgs(argv), {
-    dispatch: (command, args, context) => dispatch(command, args, { ...context, argv, authentication }),
+    dispatch: (command, args, context) => dispatch(command, args, { ...context, argv, authentication, qcStandIns }),
     closeOutStaleRunSessions,
     ambientRunSession,
     lifecycleIdentity,
@@ -699,6 +714,10 @@ export function recordQaStageOutcome(args, result) {
     const failed = (Array.isArray(verdict.assertions) ? verdict.assertions : [])
       .filter((assertion) => assertion?.status === "fail")
       .map((assertion) => `${assertion.id}: ${assertion.actual || "assertion failed"}`);
+    // The QA stamps are the verdict's: the brief material qa run bound at run
+    // start and the spec material it judged, never the inputs at write time.
+    const qaStamps = inputStamps({ briefMaterial: verdict.source_brief_material, specMaterial: verdict.spec_hash });
+    const qaInputs = stageWriteInputs("qa", currentPacketInputs({ packet, packetPath }));
     const committed = commitAssemblyReport(workspace, (report) => {
       if (hasLocalIdentity && !specHashesMatch(verdict.spec_hash, report.identity?.spec_material_hash)) {
         throw new Error("Local-spec QA verdict belongs to a different material revision; report evidence was not changed.");
@@ -719,11 +738,13 @@ export function recordQaStageOutcome(args, result) {
         // Which build this verdict judged, and the gates whose browser outcome
         // the doctor's static scan defers to (qaGatePassedForCurrentBuild). A
         // gate that never ran is left out, so silence never reads as a pass.
-        evidence: qaStageGateEvidence(verdict, report),
+        evidence: qaStageGateEvidence(verdict, report, result),
         // Counts-only: never order ids, refs, emails or URLs (see
         // summarizePurchaseProof). This is what lets `next` tell a real purchase
         // path from a `--test-order off` diagnostic.
         proof: summarizePurchaseProof({ verdict, proofPolicy: packet.qa?.proof_policy }),
+        stamps: qaStamps,
+        inputs: qaInputs,
       });
     }, {
       stage: "qa",
@@ -755,12 +776,21 @@ export function recordQaStageOutcome(args, result) {
   }
 }
 
-function qaStageGateEvidence(verdict, report) {
+// QC results are written on every QA record, with the build
+// they were measured against, whether or not a gate outcome is recorded: a
+// record without qc_results reads as captured by an earlier version. The rows
+// come from the QA run's own result; readers re-derive them from the full
+// verdict's qc.* assertions.
+function qaStageGateEvidence(verdict, report, result = null) {
   const gates = {};
   const placeholderText = summarizePlaceholderTextGate(verdict);
   if (placeholderText) gates[QA_GATE_PLACEHOLDER_TEXT_RESIDUE] = placeholderText;
-  if (!Object.keys(gates).length) return null;
-  return { source_build_fingerprint: currentBuildFingerprint(report), gates };
+  const qc = {
+    qc_results: Array.isArray(result?.qc_results) ? result.qc_results : [],
+    qc_build_fingerprint: currentBuildFingerprint(report),
+  };
+  if (!Object.keys(gates).length) return qc;
+  return { source_build_fingerprint: currentBuildFingerprint(report), gates, ...qc };
 }
 
 // What the auto-end says when the attempt does NOT end the session. Every
@@ -892,7 +922,7 @@ const PREPARE_MODES = Object.freeze({
 // no ambient session, and ahead of help routing, so `login --help`, `demo
 // --help` and `tooling setup --help` reach their own handlers. `argv` is the
 // unparsed argv, for the handlers that must see repeated tokens.
-async function dispatch(command, args, { recorder = NOOP_RECORDER, ambient = null, sessionHolder = null, argv, authentication } = {}) {
+async function dispatch(command, args, { recorder = NOOP_RECORDER, ambient = null, sessionHolder = null, argv, authentication, qcStandIns } = {}) {
   // Authentication never recovers/remits run sessions or records argv in a
   // lifecycle journal. Credentials belong only in the user credential store.
   if (command === "login" || command === "logout") {
@@ -1000,7 +1030,7 @@ async function dispatch(command, args, { recorder = NOOP_RECORDER, ambient = nul
     // The live campaign ref check's one read (#533), made before the
     // synchronous inspection; see readDoctorLiveCampaign.
     const liveCampaign = await readDoctorLiveCampaign(args);
-    const result = doctorCommand(args, { liveCampaign });
+    const result = doctorCommand(args, { liveCampaign, qcStandIns });
     writeResult(result, args, result.ok ? 0 : 2);
     printDoctorTinyPrompt(result, args);
     return;
@@ -1055,6 +1085,12 @@ async function dispatch(command, args, { recorder = NOOP_RECORDER, ambient = nul
   }
 
   if (command === "checkpoint") {
+    if (args._[1] === "accept") {
+      const result = await checkpointAcceptCommand(args, { argv, qcStandIns });
+      if (!result) return;
+      writeResult(result, args, result.ok ? 0 : 2);
+      return;
+    }
     const result = waiveOrRefuse(args, () => checkpointCommand(args), {
       gate: optionalString(args.gate) || null,
       registeredGates: Object.keys(CHECKPOINT_EVALUATORS),
@@ -1154,7 +1190,10 @@ async function dispatch(command, args, { recorder = NOOP_RECORDER, ambient = nul
     // stage from the current report + doctor state. Existing form with an
     // explicit stage (`next build`, `next polish`, etc.) is unchanged.
     const stage = args._[1] || null;
-    const result = nextStage(stage, args, ambient);
+    // The QC handoff re-derives QA and Polish results through the check
+    // registry, whose check modules load lazily, so they are loaded here.
+    const qcRederivers = await loadQcRederivers();
+    const result = nextStage(stage, args, ambient, { qcStandIns, qcRederivers });
     await observeProgress(args, result, { packageVersion: packageVersion(), resolveKey: resolveCampaignsApiKeySource });
     writeResult(result, args, result.ok ? 0 : 2);
     printNextTinyPrompt(result, args);
@@ -1410,8 +1449,7 @@ function createInitialAssemblyReportStages({ scaffoldRequired, blockers, outputs
   // (STAGE_TERMINAL_STATUS_PREFIXES): declared out-of-scope pages do not hold
   // the ladder, they are recorded on the stage so downstream consumers can see
   // exactly which pages assemble from the template family instead of source HTML.
-  const terminalStatus = declaredScopeSkips.length ? "completed_partial" : "completed";
-  stages.prepare_build = createStage("prepare_build", blockers.length ? "blocked" : terminalStatus, {
+  stages.prepare_build = createStage("prepare_build", prepareBuildStageStatus({ blockers, declaredScopeSkips }), {
     outputs,
     blockers,
     ...(declaredScopeSkips.length ? { declared_out_of_scope: declaredScopeSkips } : {}),
@@ -1762,6 +1800,10 @@ function prepareBuildUnderLock({
     sourceRoot,
     targetRepo,
   });
+  // The report and normalized brief this run replaces: the report's brief
+  // mode keeps an existing prepared campaign prepared (when it is this
+  // campaign's report), and the previous brief carries field provenance.
+  const priorBriefInputs = priorBriefInputsForIntake({ reportPath, briefPath, identity: { spec: { map_id: mapId, ...(localSpecId ? { local_spec_id: localSpecId } : {}) }, campaign: { public_route_slug: publicRouteSlug } } });
   const buildBrief = createCampaignBuildBriefArtifact({
     inputPath: briefDiscovery?.path || null,
     inputSource: briefDiscovery?.source || null,
@@ -1771,10 +1813,19 @@ function prepareBuildUnderLock({
     templateFamily,
     sourceAssetCrawl,
     commerceZoneFindings,
+    boundReportMode: priorBriefInputs.boundReportMode,
+    previousNormalizedBrief: priorBriefInputs.previousNormalizedBrief,
   });
   if (buildBrief.inputPath && buildBrief.artifact?._meta) {
     buildBrief.artifact._meta.input_path = relFromFile(briefPath, buildBrief.inputPath);
   }
+  const briefBindings = briefIntakeBindings(buildBrief);
+  // The packet settings this run writes, checked against the packet on disk
+  // before anything is published.
+  const deploySettings = {
+    target: optionalString(args["deploy-target"], "unknown"),
+    preview_url: optionalString(args["preview-url"]),
+  };
   const buildBriefPrompts = buildBrief.mode === "prepared" ? [] : buildBrief.questions.map((question) => ({
     code: `BUILD_BRIEF_${toConstantCase(question.id)}`,
     stage: "prepare_build",
@@ -1808,6 +1859,11 @@ function prepareBuildUnderLock({
       }))
     : [];
   const designSourcePackage = publication.package({
+    plannedPacket: {
+      campaign: { allowed_domains_confirmed: args["allowed-domains-confirmed"] === true },
+      deploy: { ...deploySettings, production_url: optionalString(args["production-url"]) },
+      qa: { proof_policy: { order_path_depth: orderPathDepthFlag || "common" } },
+    },
     activePages,
     mappings: matched.mappings,
     manifestResult,
@@ -1859,6 +1915,7 @@ function prepareBuildUnderLock({
       normalized_path: relFromFile(packetPath, briefPath),
       question_count: buildBrief.questions.length,
       gate_count: buildBrief.gates.length,
+      ...briefBindings,
     },
     assembly: {
       implementation: "next-campaigns-build",
@@ -1886,14 +1943,13 @@ function prepareBuildUnderLock({
       compatible_outputs: ["static-html", "campaign-cart-sdk"],
     },
     deploy: {
-      target: optionalString(args["deploy-target"], "unknown"),
-      preview_url: optionalString(args["preview-url"]),
+      ...deploySettings,
       production_url: optionalString(args["production-url"]),
       live_url_path: liveUrlPath,
     },
     qa: {
       proof_policy: proofPolicy,
-      test_order_policy_notes: "Test Orders use global test cards that bypass the gateway and create no transactions. Run them any time with `qa run --test-order common`: when every actual terminal path in the selected checkout topology fits under the flood cap, common runs them all (effective depth `full`, reason `under_cap`); above the cap it runs checkout, first-offer accept/decline and a deduplicated shortest real receipt path, then adds the shortest path that clicks the decline on each offer or downsell page no planned path declines yet, up to the cap, and names any page left out. The `browser-test-order:upsell-action-coverage` verdict row warns naming each offer page whose decline no executed order clicked. Use `--test-order full` for every actual terminal path in the selected checkout topology; cycles, missing routes, and reachable nonterminals block exhaustive proof before browser launch. Use `--test-order tiers` (or `tiers:common` / `tiers:full`) to drive one strict-selection order per selector tier the CampaignSpec declares on the checkout page, crossed with those path shapes; order-bump rows marked `is_upsell` are add-ons, not tiers, so a three-tier checkout with one bump plans 3 tiers, and `--select-package <ref[:qty],...>` narrows a tiers run to the listed tiers. The default accidental-flood cap is 6, and an overflow names the exact explicit `--max-test-orders` raise and lists the planned paths (up to 40 ids, the remainder counted). That cap bounds planned paths; `--max-order-creations` bounds actual order creations, defaults to the planned path count, and is reserved before each submit. Localhost on any port is a globally allowed Development domain; non-localhost preview/production origins still need SDK origin allowlist confirmation. There is no permission flag: depth is the only control.",
+      test_order_policy_notes: "Test Orders use global test cards that bypass the gateway and create no transactions. Run them any time with `qa run --test-order common`: when every actual terminal path in the selected checkout topology fits under the flood cap, common runs them all (effective depth `full`, reason `under_cap`); above the cap it runs checkout, first-offer accept/decline and a deduplicated shortest real receipt path, then adds the shortest path that clicks the decline on each offer or downsell page no planned path declines yet, up to the cap, and names any page left out. The `browser-test-order:upsell-action-coverage` verdict row warns naming each offer page whose decline no executed order clicked. Use `--test-order full` for every actual terminal path in the selected checkout topology; cycles, missing routes, and reachable nonterminals block exhaustive proof before browser launch. Use `--test-order tiers` (or `tiers:common` / `tiers:full`) to drive one strict-selection order per selector tier the CampaignSpec declares on the checkout page, crossed with those path shapes; order-bump rows marked `is_order_bump` or `is_upsell` are add-ons, not tiers, so a three-tier checkout with one bump plans 3 tiers, and `--select-package <ref[:qty],...>` narrows a tiers run to the listed tiers. The default accidental-flood cap is 6, and an overflow names the exact explicit `--max-test-orders` raise and lists the planned paths (up to 40 ids, the remainder counted). That cap bounds planned paths; `--max-order-creations` bounds actual order creations, defaults to the planned path count, and is reserved before each submit. Localhost on any port is a globally allowed Development domain; non-localhost preview/production origins still need SDK origin allowlist confirmation. There is no permission flag: depth is the only control.",
     },
     notes: "Generated by campaigns-os prepare-build. Replace demo refs from CampaignSpec/API before launch.",
   };
@@ -1974,6 +2030,7 @@ function prepareBuildUnderLock({
       gate_count: buildBrief.gates.length,
       questions: buildBrief.questions,
       gates: buildBrief.gates,
+      ...briefBindings,
     },
     page_map: matched.mappings.map((mapping) => ({
       page_id: mapping.page_id,
@@ -2021,13 +2078,14 @@ function prepareBuildUnderLock({
   if (!writtenTheme.ok && Array.isArray(writtenTheme.errors) && writtenTheme.errors.length > 0) {
     context.theme.warnings = [
       ...(context.theme.warnings || []),
-      ...writtenTheme.errors.map((error) => ({ code: error.code, message: error.message, detail: error.detail || null })),
+      ...writtenTheme.errors.map(themeIssueForReport),
     ];
   }
 
   // The top-level status/next/blockers are derived from the stages by the same
   // function every later commit of the report runs (stage-ledger.mjs), so
-  // prepare-build's first write and a producer's last write spell them alike.
+  // prepare-build's first write and a producer's last write spell them alike,
+  // against the brief and CampaignSpec material this run binds.
   const report = applyDerivedAssemblyReportSummary(createAssemblyReport({
     packetPath,
     contextPath,
@@ -2044,7 +2102,7 @@ function prepareBuildUnderLock({
     buildScopeReasonsInvalid,
     templateSelection,
     evidence: strippedSpecBytes == null ? [] : hostStripped.evidence,
-  }));
+  }), { briefMaterial: briefBindings.material, specMaterial: specMaterialHash(spec) });
 
   // Values a spec left as it is still holds that doctor blocks on. An
   // absolute http(s) page_url is not among them: projection takes its path.
@@ -2615,7 +2673,7 @@ export function commitWaiverToAssemblyReport(workspace, mutate, options, { dryRu
     // run's own "do not write" is this wrapper's null below, not the mutator's.
     if (!isPlainObject(mutated)) throw new TypeError("commitAssemblyReport mutate(report) must return an Assembly Report object.");
     if (!dryRun) return mutated;
-    applyDerivedAssemblyReportSummary(mutated);
+    applyDerivedAssemblyReportSummary(mutated, currentPacketInputs({ packet: workspace.packet, packetPath: workspace.packetPath }));
     return null;
   };
   // A preview writes nothing, so it does not take the target lock either: the
@@ -2670,7 +2728,19 @@ export async function polishCaptureCommand(args, options = {}) {
     throw new Error(`polish capture needs an existing Assembly Report at ${reportPath}; run prepare-build/start first.`);
   }
   requireValidPolishCaptureReport(report, reportPath);
-  const plan = planPolishCapture({ packet, baseUrl });
+  // A campaign whose every mapping is template stock has no page_load route
+  // to capture: its plan error is held, and the capture measures readability
+  // on the built pages only, leaving page_load and media_weight as they are.
+  const { capturePolishReadability, isNoCapturableRoutesError } = await import("./polish-node.mjs");
+  const planOrHeld = (currentPacket) => {
+    try {
+      return { plan: planPolishCapture({ packet: currentPacket, baseUrl }), held: null };
+    } catch (error) {
+      if (!isNoCapturableRoutesError(error)) throw error;
+      return { plan: null, held: error };
+    }
+  };
+  const { plan, held: heldPlanError } = planOrHeld(packet);
   const initialBinding = createPolishCaptureBinding({
     packet,
     report,
@@ -2683,7 +2753,7 @@ export async function polishCaptureCommand(args, options = {}) {
   if (typeof createBrowserAdapter !== "function") {
     ({ createPolishBrowserAdapter: createBrowserAdapter } = await import("./polish-browser.mjs"));
   }
-  const capture = await capturePolishPageLoad({
+  const capture = await (heldPlanError ? capturePolishReadability : capturePolishPageLoad)({
     packet,
     report,
     baseUrl,
@@ -2693,7 +2763,11 @@ export async function polishCaptureCommand(args, options = {}) {
     adapterStartupDeadlineMs: options.adapterStartupDeadlineMs,
     captureCellDeadlineMs: options.captureCellDeadlineMs,
     adapterCloseDeadlineMs: options.adapterCloseDeadlineMs,
+    probeClock: options.probeClock,
+    targetRepo,
   });
+  // Nothing was measured: the held plan error stands.
+  if (heldPlanError && !capture.readability) throw heldPlanError;
 
   if (typeof options.afterCapture === "function") {
     await options.afterCapture({ packetPath, reportPath, targetRepo, capture });
@@ -2706,7 +2780,7 @@ export async function polishCaptureCommand(args, options = {}) {
   let checkpoint = null;
   commitAssemblyReport(workspace, (currentReport) => {
     requireValidPolishCaptureReport(currentReport, reportPath);
-    const currentPlan = planPolishCapture({ packet: currentPacket, baseUrl });
+    const { plan: currentPlan } = planOrHeld(currentPacket);
     const currentBinding = createPolishCaptureBinding({
       packet: currentPacket,
       report: currentReport,
@@ -2716,7 +2790,12 @@ export async function polishCaptureCommand(args, options = {}) {
     });
     assertPolishCaptureBindingUnchanged(initialBinding, currentBinding);
 
-    const merged = mergePolishPageLoadEvidence(currentReport, capture.page_load);
+    const merged = mergePolishCaptureEvidence(currentReport, {
+      pageLoad: capture.page_load,
+      mediaWeight: capture.media_weight,
+      readability: capture.readability,
+      now: options.now ?? new Date(),
+    });
     checkpoint = evaluateRecordedHiddenEagerMediaCheckpoint({
       packet: currentPacket,
       report: merged,
@@ -2727,19 +2806,39 @@ export async function polishCaptureCommand(args, options = {}) {
     staleReason: `Package-owned polish page-load evidence changed after this doctor snapshot. Re-run ${cmd("doctor")} (or next) for current state.`,
   });
 
+  if (heldPlanError) {
+    // The readability capture completed; page_load's own outcome stays the
+    // held no_capturable_routes message, reported as a warning.
+    return {
+      ok: true,
+      status: "captured_with_warnings",
+      action: "polish-capture",
+      report_path: reportPath,
+      measurement: null,
+      checkpoint,
+      observed_findings: [],
+      warnings: [{ code: heldPlanError.code, message: heldPlanError.message }],
+      capture: {
+        route_scope: null,
+        routes: [],
+        viewports: [],
+        readability_routes: capture.readability?.subject?.routes ?? [],
+      },
+    };
+  }
   const ok = checkpoint.status === "pass" || checkpoint.status === "waived";
   return {
     ok,
     status: ok ? (checkpoint.status === "waived" ? "ready_with_waivers" : "ready") : "blocked",
     action: "polish-capture",
     report_path: reportPath,
-    measurement: capture.page_load.measurement,
+    measurement: capture.page_load?.measurement ?? null,
     checkpoint,
-    observed_findings: capture.page_load.findings,
+    observed_findings: capture.page_load?.findings ?? [],
     capture: {
-      route_scope: capture.plan.route_scope,
-      routes: capture.plan.routes.map((route) => route.requested_route),
-      viewports: capture.plan.viewports.map((viewport) => viewport.key),
+      route_scope: capture.plan?.route_scope ?? null,
+      routes: (capture.plan?.routes ?? []).map((route) => route.requested_route),
+      viewports: (capture.plan?.viewports ?? []).map((viewport) => viewport.key),
     },
   };
 }
@@ -2811,7 +2910,7 @@ function waiveOrRefuse(args, run, { gate = null, registeredGates = [] } = {}) {
 function checkpointCommand(args) {
   const subcommand = args._[1] || "help";
   if (subcommand !== "waive") {
-    throw refused(`Unknown checkpoint subcommand. Use: ${cmd("checkpoint")} waive --packet <campaign-runtime.build.json> --gate <checkpoint-id> [--page <page_id>] --reason "<why>" --waived-by "<named human>" [--expires-at <ISO>] [--review-condition "<trigger>"]. Registered gates: ${Object.keys(CHECKPOINT_EVALUATORS).join(", ")}.`);
+    throw refused(`Unknown checkpoint subcommand. Use: ${cmd("checkpoint")} waive --packet <campaign-runtime.build.json> --gate <checkpoint-id> [--page <page_id>] --reason "<why>" --waived-by "<named human>" [--expires-at <ISO>] [--review-condition "<trigger>"]. Registered gates: ${Object.keys(CHECKPOINT_EVALUATORS).join(", ")}. Or: ${cmd("checkpoint")} accept --packet <campaign-runtime.build.json> --result <result_id>@<fingerprint12> [--result …] --reason "<the operator's reason>" --accepted-by "<operator's name>" [--expires-at <ISO>] [--review-condition "<trigger>"] [--report <json>] [--dry-run].`);
   }
   return checkpointWaive(args);
 }
@@ -2934,6 +3033,170 @@ export function checkpointWaive(args) {
   };
 }
 
+// `checkpoint accept`: records an operator's accept of a
+// measured QC warning in report.qc_accepts[], beside the unchanged
+// measurement. It reads only what is already on disk (doctor recomputed
+// offline, the persisted doctor sidecar, the Assembly Report and the full QA
+// verdict the QA stage names) and sends nothing. Every listed result must be a
+// current accept-eligible warning that was on record before this command;
+// the check runs again under the report lock immediately before the one
+// write, and if any ref fails nothing is written.
+const CHECKPOINT_ACCEPT_VALUE_FLAGS = Object.freeze({
+  packet: "<campaign-runtime.build.json>",
+  result: "<result_id>@<fingerprint12>",
+  reason: "\"<the operator's reason>\"",
+  "expires-at": "<ISO>",
+  "review-condition": "\"<trigger>\"",
+  report: "<json>",
+});
+
+// Every value of a flag the operator may repeat, from the raw argv: the shared
+// parser keeps only the last.
+function repeatedFlagValues(argv, flag) {
+  const values = [];
+  const tokens = Array.isArray(argv) ? argv : [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (tokens[index] !== `--${flag}`) continue;
+    const next = tokens[index + 1];
+    values.push(next === undefined || next.startsWith("--") ? null : next);
+  }
+  return values;
+}
+
+function qcAcceptRefusalEnvelope(error) {
+  return {
+    ok: false,
+    refusal_code: error.code,
+    error: error.message,
+    ...(error.refused?.length ? { refused: error.refused.map(({ result_ref, refusal_code }) => ({ result_ref, refusal_code })) } : {}),
+  };
+}
+
+export async function checkpointAcceptCommand(args, { argv = [], qcStandIns = null } = {}) {
+  try {
+    const qcRederivers = await loadQcRederivers();
+    return checkpointAccept(args, { argv, qcStandIns, qcRederivers });
+  } catch (error) {
+    // A typed refusal is an invocation refusal like every untyped one
+    // (refused() marks this invocation's refusal scope), so a refused accept
+    // journals nothing, rendered under --json or thrown without it.
+    const refusal = error instanceof QcAcceptRefusal ? refused(`${error.message} (${error.code})`) : error;
+    if (args.json !== true) throw refusal;
+    const envelope = error instanceof QcAcceptRefusal ? qcAcceptRefusalEnvelope(error) : { ok: false, error: String(error?.message ?? error) };
+    console.log(JSON.stringify(envelope, null, 2));
+    console.error(`campaigns-os: ${envelope.error}`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+
+export function checkpointAccept(args, { argv = [], qcStandIns = null, qcRederivers = null } = {}) {
+  // The command clock; no flag sets accepted_at.
+  const now = new Date().toISOString();
+  const acceptedByValues = repeatedFlagValues(argv, "accepted-by");
+  const acceptedBy = acceptedByValues.length === 1 && isNonEmptyString(args["accepted-by"]) ? args["accepted-by"] : null;
+  if (acceptedByValues.length > 1) throw refused("checkpoint accept takes one --accepted-by: one operator decides one accept command.");
+  for (const [key, placeholder] of Object.entries(CHECKPOINT_ACCEPT_VALUE_FLAGS)) {
+    if (!Object.hasOwn(args, key) || args[key] == null) continue;
+    if (!isNonEmptyString(args[key])) throw refused(`--${key} needs a value: pass --${key} ${placeholder}.`);
+  }
+  if (repeatedFlagValues(argv, "reason").length > 1) throw refused("checkpoint accept takes one --reason per invocation: the operator's reason, verbatim.");
+  const packetPath = resolve(requireArg(args, "packet"));
+  const dryRun = isDryRun(args);
+  const refValues = repeatedFlagValues(argv, "result");
+  if (!refValues.length) throw refused(`checkpoint accept needs at least one --result <result_id>@<fingerprint12>, as the QC handoff of \`${cmd("next")}\` prints it.`);
+  const refs = refValues.map((value) => {
+    const parsed = parseQcResultRef(value);
+    if (!parsed) throw refused(`--result ${JSON.stringify(value)} is not <result_id>@<fingerprint12>; copy the ref the QC handoff of \`${cmd("next")}\` prints.`);
+    return parsed;
+  });
+  const duplicate = refs.find((ref, index) => refs.findIndex((other) => other.id === ref.id) !== index);
+  if (duplicate) throw refused(`--result names "${duplicate.id}" more than once; list each result once.`);
+  const attribution = qcAcceptAttribution({
+    reason: args.reason,
+    acceptedBy,
+    now,
+    expiresAt: args["expires-at"] ?? null,
+    reviewCondition: args["review-condition"] ?? null,
+  });
+
+  const packet = readJson(packetPath);
+  const workspace = resolveCampaignWorkspace(packetPath, {
+    packet,
+    reportPath: args.report == null ? undefined : resolve(args.report),
+    followContextPointer: false,
+  });
+  const { reportPath, targetRepo, doctorOutPath } = workspace;
+  if (!existsSync(reportPath)) throw refused(`checkpoint accept needs an assembly report at ${reportPath}; run prepare-build/start first.`);
+  // An accept only appends. A qc_accepts or evidence value that is not an
+  // array is refused, never replaced, so the value already there stays as it
+  // is (checked on the read before the lock and again under it).
+  const refuseUnappendable = (report) => {
+    for (const field of ["qc_accepts", "evidence"]) {
+      if (isPlainObject(report) && Object.hasOwn(report, field) && !Array.isArray(report[field])) {
+        throw refused(`checkpoint accept refused; nothing was written: report.${field} in ${reportPath} is not an array, and an accept only appends to it. It was left as it is; repair it before accepting.`);
+      }
+    }
+  };
+
+  // Doctor is recomputed offline (no live refs), the spec read the way `next`
+  // reads it, and every leg's results taken from its reader site.
+  const plan = (report) => {
+    const doctor = doctorPacket(packetPath, { reportPath, ...(qcStandIns ? { qcStandIns } : {}) });
+    let spec = null;
+    try {
+      spec = readJsonIfExists(doctor.derived?.spec_path || null);
+    } catch {
+      spec = null;
+    }
+    const { results } = readCurrentQcResults({ report, doctor, spec, targetRepo, packetPath, reportPath, qcStandIns, rederivers: qcRederivers });
+    return planQcAccepts({ refs, results, sidecarPath: doctorOutPath, now, attribution });
+  };
+  // Checked once before taking the lock, so a refusal touches nothing, and
+  // again on the report read under the lock, immediately before the write.
+  const unlocked = readJson(reportPath);
+  refuseUnappendable(unlocked);
+  plan(unlocked);
+  let records = [];
+  const recordAccepts = (report) => {
+    refuseUnappendable(report);
+    records = plan(report);
+    return {
+      ...report,
+      qc_accepts: [...(report.qc_accepts ?? []), ...records],
+      evidence: [
+        ...(report.evidence ?? []),
+        ...records.map((record) => `QC accept: ${record.result_id}@${fingerprint12(record.state_fingerprint)} (${record.leg}) accepted by ${record.accepted_by} at ${record.accepted_at}: ${record.reason}`),
+      ],
+    };
+  };
+  commitWaiverToAssemblyReport(workspace, recordAccepts, {
+    command: "checkpoint accept",
+    staleReason: `A QC accept was recorded after this doctor snapshot. Re-run ${cmd("doctor")} (or next) for current state.`,
+  }, { dryRun });
+  const accepts = records.map(projectQcAccept);
+  if (dryRun) {
+    return {
+      ok: true,
+      status: "dry_run",
+      dry_run: true,
+      action: "checkpoint-accept",
+      accepts,
+      report_path: reportPath,
+      would_write: reportPath,
+      note: "Dry run: nothing was written and the doctor sidecar was not marked stale. Re-run without --dry-run to record these accepts.",
+    };
+  }
+  return {
+    ok: true,
+    status: "recorded",
+    action: "checkpoint-accept",
+    accepts,
+    report_path: reportPath,
+    note: "Each accept changes only the result's disposition to operator_accepted. The warning, doctor status, next status and QA disposition are unchanged, and the accept lapses when the measured state or the build changes.",
+  };
+}
+
 // `page-kit sync`: write the CampaignSpec's Store Profile fields and SDK pin
 // into the target's _data/campaigns.json entry for the packet's route. This is
 // the recovery the two page-kit gates name: a fresh scaffold seeds the entry
@@ -3317,7 +3580,6 @@ export function specDeriveCommand(args, { store: storeRead = null } = {}) {
     store: storeFlags
       ? { subdomain: storeFlags.subdomain, admin_api: adminApiBaseForStore(storeFlags.subdomain), ...(storeFlags.token_env ? {} : { transport: "gateway", endpoint: "https://mcp.nextcommerce.com/admin/" }), token_source: storeFlags.token_env ? `env:${storeFlags.token_env}` : "gateway:login", store_read: null, pages_read: null, primary_domain: null }
       : null,
-    rebound: { build_context: null, assembly_report: null },
     errors: [],
     warnings: [],
     next: `${cmd("doctor")} --packet ${shellToken(packetPath)}`,
@@ -3551,17 +3813,15 @@ export function specDeriveCommand(args, { store: storeRead = null } = {}) {
       addIssue(result.warnings, "spec.derive.projection_stale", `A page route ${dryRun ? "would move" : "moved"}, and the packet's page-kit projection (source_html.pages[].page_kit) and the Build Context were prepared from the old routes. Re-run ${cmd("prepare-build")} (or start) before the next build so they describe the routes the spec carries.`);
     }
     if (stageIsTerminal(report?.stages?.assembly?.status)) {
-      addIssue(result.warnings, "spec.derive.build_stale", `The Assembly Report records a terminal build (stages.assembly.status ${report.stages.assembly.status}) rendered from the spec ${dryRun ? "this would rewrite" : "just rewritten"}. Re-run the build stage before polish, deploy or QA if a route or the pin moved; QA correlates its verdict against the spec identity the sidecars carry.`);
-      result.next = `${cmd("doctor")} --packet ${shellToken(packetPath)}, then rebuild: set stages.assembly.status back to "pending" on the Assembly Report and run ${cmd("next")} --packet ${shellToken(packetPath)}`;
+      addIssue(result.warnings, "spec.derive.build_stale", `The Assembly Report records a terminal build (stages.assembly.status ${report.stages.assembly.status}) rendered from the spec ${dryRun ? "this would rewrite" : "just rewritten"}. Bind the rewritten spec with ${cmd("record")} spec (it keeps stage history); next then routes back to the build, and Polish and QA are owed again.`);
     }
+    // spec derive writes the spec alone: the Build Context and the Assembly
+    // Report keep the identity they bound, so every recorded stage reads its
+    // stamps against the new content and `record spec` is what binds it.
+    if (report) result.next = `${cmd("record")} spec --packet ${shellToken(packetPath)} ${dryRun ? "after the write " : ""}to bind the derived spec (it keeps stage history), then ${cmd("next")} --packet ${shellToken(packetPath)}`;
   }
 
   if (plan.changes.length && !dryRun) {
-    // The identity the sidecars bound to the spec BEFORE this write, so the
-    // re-bind below can tell "bound to the spec being replaced" from "already
-    // drifted" and only ever moves the former.
-    const beforeRawHash = createHash("sha256").update(text).digest("hex");
-    const beforeMaterialHash = specMaterialHash(spec);
     // The plan already refused every path its containers cannot take, so a
     // throw here is a defect in this toolkit rather than in the spec; it is
     // still a structured error, never a crash past the --json contract.
@@ -3599,82 +3859,7 @@ export function specDeriveCommand(args, { store: storeRead = null } = {}) {
       rmSync(tmpPath, { force: true });
     }
     result.written = true;
-    // The Build Context and the Assembly Report carry the spec's identity
-    // (raw and material hashes) from prepare-build, and QA's verdict is
-    // correlated against the material hash by the bundle check. Each sidecar
-    // that was bound to the spec just replaced is re-bound to the new one;
-    // one that already carried another identity is left as it is and named.
-    const afterRawHash = createHash("sha256").update(serialized).digest("hex");
-    const afterMaterialHash = specMaterialHash(spec);
-    const boundToOld = (raw, material) => raw === beforeRawHash || material === beforeMaterialHash;
-    // A sidecar is re-bound only when it names the spec being written: two
-    // packets sharing a target repo can carry byte-identical spec exports,
-    // and a matching hash alone would let one packet's derive re-bind the
-    // other's sidecar to a spec it never used.
-    const namesThisSpec = (recorded) => {
-      if (!isNonEmptyString(recorded)) return false;
-      try {
-        return realpathSync(resolve(targetRepo, recorded)) === realSpecPath;
-      } catch {
-        return false;
-      }
-    };
-    const contextPath = workspace?.contextPath || null;
-    let context = null;
-    try {
-      context = contextPath ? readJsonIfExists(contextPath) : null;
-    } catch (error) {
-      result.rebound.build_context = false;
-      addIssue(result.warnings, "spec.derive.identity_not_rebound", `The Build Context could not be read (${singleLineDetail(error.message)}); its spec identity was not updated. Re-run prepare-build before QA so the bundle correlates.`);
-    }
-    if (isObject(context?.spec)) {
-      if (!namesThisSpec(context.spec.path)) {
-        result.rebound.build_context = false;
-        addIssue(result.warnings, "spec.derive.identity_not_rebound", "The Build Context names a different spec file than the one derive wrote (another packet's, or a moved export); it was left as it is. Re-run prepare-build before QA so the bundle correlates.");
-      } else if (boundToOld(context.spec.hash, context.spec.material_hash)) {
-        try {
-          writeJsonAtomic(contextPath, { ...context, spec: { ...context.spec, hash: afterRawHash, material_hash: afterMaterialHash } });
-          result.rebound.build_context = true;
-        } catch (error) {
-          result.rebound.build_context = false;
-          addIssue(result.warnings, "spec.derive.identity_not_rebound", `The Build Context's spec identity could not be updated (${singleLineDetail(error.message)}); re-run prepare-build before QA so the bundle correlates.`);
-        }
-      } else {
-        result.rebound.build_context = false;
-        addIssue(result.warnings, "spec.derive.identity_not_rebound", `The Build Context's spec identity was already bound to a different spec than the one derive replaced; it was left as it is. Re-run prepare-build before QA so the bundle correlates.`);
-      }
-    }
-    if (report && isObject(report.identity) && workspace) {
-      if (!namesThisSpec(report.inputs?.spec_path)) {
-        result.rebound.assembly_report = false;
-        addIssue(result.warnings, "spec.derive.identity_not_rebound", "The Assembly Report names a different spec file than the one derive wrote (another packet's, or a moved export); it was left as it is. Re-run prepare-build before QA so the bundle correlates.");
-      } else if (boundToOld(report.identity.spec_hash, report.identity.spec_material_hash)) {
-        try {
-          // The identity is re-checked on the report as it is re-read for
-          // the commit, so a prepare-build that re-bound it in the meantime
-          // is left alone.
-          const committed = commitAssemblyReport(workspace, (current) => (
-            isObject(current.identity) && boundToOld(current.identity.spec_hash, current.identity.spec_material_hash)
-              ? { ...current, identity: { ...current.identity, spec_hash: afterRawHash, spec_material_hash: afterMaterialHash } }
-              : null
-          ), {
-            command: "spec derive",
-            staleReason: `spec derive rewrote the CampaignSpec after this doctor snapshot. Re-run ${cmd("doctor")} (or next) for current state.`,
-          });
-          result.rebound.assembly_report = committed.written;
-          if (!committed.written) addIssue(result.warnings, "spec.derive.identity_not_rebound", "The Assembly Report's spec identity moved while spec derive was running; it was left as it is. Re-run prepare-build before QA so the bundle correlates.");
-        } catch (error) {
-          result.rebound.assembly_report = false;
-          addIssue(result.warnings, "spec.derive.identity_not_rebound", `The Assembly Report's spec identity could not be updated (${singleLineDetail(error.message)}); re-run prepare-build before QA so the bundle correlates.`);
-        }
-      } else {
-        result.rebound.assembly_report = false;
-        addIssue(result.warnings, "spec.derive.identity_not_rebound", `The Assembly Report's spec identity was already bound to a different spec than the one derive replaced; it was left as it is. Re-run prepare-build before QA so the bundle correlates.`);
-      }
-    }
     // The retained doctor snapshot (if any) now predates the spec it judged.
-    // commitAssemblyReport stamps it when the report was re-bound; every
-    // other path stamps it here.
     try {
       markDoctorSidecarStale(targetRepo, {
         command: "spec derive",
@@ -3810,8 +3995,8 @@ export function pageKitParityCommand(args, options = {}) {
   const environment = recordedBuildEnvironment(report);
   if (environment !== LOCAL_PROOF_BUILD_ENVIRONMENT) {
     addIssue(result.warnings, LOCAL_PROOF_BUILD_ENVIRONMENT_SCOPE, environment
-      ? `${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} is "${singleLineField(environment)}", not "${LOCAL_PROOF_BUILD_ENVIRONMENT}". If _site/ is a production build, the comparison below fails as proven_output_stale on the first environment-gated line; rebuild with ${LOCAL_PROOF_BUILD_COMMAND} and record the environment.`
-      : `${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} is not recorded. The build stage under local-serve renders the development environment (${LOCAL_PROOF_BUILD_COMMAND}) and records it there; the comparison below assumes _site/ is that render.`);
+      ? `${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} is "${singleLineField(environment)}", not "${LOCAL_PROOF_BUILD_ENVIRONMENT}". If _site/ is a production build, the comparison below fails as proven_output_stale on the first environment-gated line; rebuild with ${LOCAL_PROOF_BUILD_COMMAND} and record it with ${asInvocation(substitutePacket(LOCAL_PROOF_RECORD_BUILD_COMMAND, packetPath))}.`
+      : `${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} is not recorded. The build stage under local-serve renders the development environment (${LOCAL_PROOF_BUILD_COMMAND}) and records it with ${asInvocation(substitutePacket(LOCAL_PROOF_RECORD_BUILD_COMMAND, packetPath))}; the comparison below assumes _site/ is that render.`);
   }
   const load = loadPageKitCampaignEntry({ targetRepo, publicRouteSlug });
   const expectedSdkVersion = load.status === "ok" && typeof load.entry?.sdk_version === "string" ? load.entry.sdk_version : null;
@@ -4038,7 +4223,7 @@ function describeDeclaredDepth(purchaseProof) {
   return `The declared order path depth is "${purchaseProof?.declared_depth || "unspecified"}"`;
 }
 
-export function nextStage(stage, args, ambient = null) {
+export function nextStage(stage, args, ambient = null, { qcStandIns = null, qcRederivers = null } = {}) {
   if (stage !== null && !NEXT_STAGE_ORDER.includes(stage)) {
     throw refused(`Unknown next stage: ${stage}. Accepted stages: ${NEXT_STAGE_ORDER.join(", ")}.`);
   }
@@ -4053,6 +4238,8 @@ export function nextStage(stage, args, ambient = null) {
     followContextPointer: true,
   });
   const report = readJsonIfExists(reportPath);
+  // The campaign intent summary, computed once per call and only printed.
+  const intentSummary = readIntentSummary(packetPath, packet, contextPath);
   // Doctor reads the same sidecars through the same resolver (an operator's
   // explicit --context / --report passed through, the defaults derived), so
   // its prepare-build gate and its stage pick are this command's: `next`
@@ -4060,8 +4247,19 @@ export function nextStage(stage, args, ambient = null) {
   const doctor = doctorPacket(packetPath, {
     contextPath: args.context ? resolve(args.context) : undefined,
     reportPath: args.report ? resolve(args.report) : undefined,
+    ...(qcStandIns ? { qcStandIns } : {}),
   });
   const prepareBuildGate = doctor.derived?.prepare_build_gate || null;
+  // The CampaignSpec doctor just read (spec.local_path), for the QA stage's
+  // order-bump command. Best-effort: doctor reports an unreadable spec itself.
+  let spec = null;
+  let specReadError = null;
+  try {
+    spec = readJsonIfExists(doctor.derived?.spec_path || null);
+  } catch (error) {
+    spec = null;
+    specReadError = error;
+  }
   // #171: `next` recomputes doctor state on every call; persist that fresh
   // snapshot so the retained sidecar can never stay a green lie from an
   // earlier stage while the campaign degrades (the dogfood target sat
@@ -4127,13 +4325,31 @@ export function nextStage(stage, args, ambient = null) {
     } });
     if (divergences.length) result.divergences = divergences;
     result.gates = buildNextGates({ doctor, report, themeGate, polishGate, prepareBuildGate, packetPath });
-    result.next_actions = buildNextActions({ result, packetPath, packet, themeGate, polishGate, polishCheckpointGate, prepareBuildGate, ambient, runRecordCloseout, purchaseProof, brandContract: doctor.derived?.brand_contract || null, context: readJsonIfExists(contextPath), targetRepo });
+    if (doctor.derived?.input_currency) result.input_currency = doctor.derived.input_currency;
+    result.next_actions = buildNextActions({ result, packetPath, packet, themeGate, polishGate, polishCheckpointGate, prepareBuildGate, ambient, runRecordCloseout, purchaseProof, brandContract: doctor.derived?.brand_contract || null, context: readJsonIfExists(contextPath), targetRepo, spec });
+    // The QC handoff: read from data already loaded plus the
+    // full QA verdict the QA stage names. It adds nothing to errors[],
+    // warnings[] or ready[], and `status` above never reads it. Its accept
+    // command names the report this run read when that is not the default
+    // one (from --report or the Build Context pointer), so it records there.
+    const qc = readCurrentQcResults({ report, doctor, spec, targetRepo, packetPath, reportPath, qcStandIns, rederivers: qcRederivers });
+    result.qc_handoff = buildQcHandoff({ results: qc.results, coverage: qc.coverage, accepts: report?.qc_accepts, packetPath, reportPath: explicitReportPath(reportPath, targetRepo) });
+    // One note per operator decision that kept the build output unchanged
+    // after an input change, quoting the operator's reason.
+    for (const issue of doctor.warnings) if (issue.code === "assembly.output_unchanged_by_operator_decision") (result.qc_handoff.notes ||= []).push(`Build output kept unchanged after an input change by the operator's decision: "${issue.detail.reason}"`);
     recordNextRecommendation(ambient, result);
+    result.intent_summary = intentSummary;
     return result;
   };
   const doctorHasOnlyPolishGateErrors = doctorErrorsAreOnlyPolishGate(doctor.errors);
   const errors = [];
   const warnings = doctor.warnings.map((issue) => withPacketSubstitutedIssue(issue, packetPath));
+  if (specReadError) {
+    warnings.push({
+      code: "next.order_bump_spec_unreadable",
+      message: `The CampaignSpec at ${doctor.derived?.spec_path} could not be read (${singleLineField(specReadError.message)}), so next cannot tell whether the checkout declares an order bump and names no order-bump QA command. Fix the spec and run next again.`,
+    });
+  }
   const ready = [...doctor.ready];
   if (!doctor.ok && !doctorHasOnlyPolishGateErrors) errors.push(...doctor.errors.map((issue) => withPacketSubstitutedIssue(issue, packetPath)));
 
@@ -4214,12 +4430,12 @@ export function nextStage(stage, args, ambient = null) {
   if (stage === "setup") {
     addPrepareBuildGateErrors(errors, report);
     if (!doctor.ok && !doctorHasOnlyPolishGateErrors) addIssue(errors, "next.setup.doctor", "Doctor is blocked; resolve packet errors before setup.");
-    prompt = setupPrompt(packetPath, contextPath, reportPath, packet);
+    prompt = setupPrompt(packetPath, contextPath, reportPath, packet, intentSummary);
   } else if (stage === "build") {
     addPrepareBuildGateErrors(errors, report);
     if (!doctor.ok && !doctorHasOnlyPolishGateErrors) addIssue(errors, "next.build.doctor", "Doctor is blocked; resolve packet errors before build.");
     if (doctor.derived?.scaffold_required) addIssue(errors, "next.build.setup", doctor.derived.scaffold_reason || "Setup is required before build.");
-    prompt = buildPrompt(packetPath, contextPath, reportPath, packet, doctor.derived);
+    prompt = buildPrompt(packetPath, contextPath, reportPath, packet, doctor.derived, intentSummary);
   } else if (stage === "polish") {
     addPrepareBuildGateErrors(errors, report);
     if (!report) addIssue(errors, "next.polish.report", "Assembly report is required before polish.");
@@ -4227,7 +4443,7 @@ export function nextStage(stage, args, ambient = null) {
     if (!assemblyStatus.startsWith("completed")) addIssue(errors, "next.polish.assembly", `Assembly status is "${assemblyStatus || "missing"}"; polish expects completed assembly or an explicit blocked/skipped handoff.`);
     if (polishGateRequiresBuild(polishGate)) addPolishGateErrors(errors, polishGate, "polish");
     addThemeGateErrors(errors, themeGate, "polish");
-    prompt = polishPrompt(packetPath, reportPath, packet);
+    prompt = polishPrompt(packetPath, reportPath, packet, intentSummary);
   } else if (stage === "deploy") {
     addPrepareBuildGateErrors(errors, report);
     // Slice 3 Phase 2: deploy is an out-of-band step (Netlify / CF Pages /
@@ -4246,7 +4462,7 @@ export function nextStage(stage, args, ambient = null) {
     addPolishGateErrors(errors, polishGate, "qa");
     addPolishCheckpointGateErrors(errors, polishCheckpointGate, "qa");
     addThemeGateErrors(errors, themeGate, "qa");
-    prompt = qaPrompt(packetPath, reportPath, packet);
+    prompt = qaPrompt(packetPath, reportPath, packet, spec, intentSummary);
   }
   const status = errors.length
     ? "blocked"
@@ -4513,7 +4729,7 @@ function divergenceInspectAction(divergences, packetPath) {
 
 // Executable next actions: exact commands (or explicitly-manual steps), never
 // prose-only guidance. Ordering is the execution order an agent should follow.
-export function buildNextActions({ result, packetPath, packet, themeGate, polishGate, polishCheckpointGate, prepareBuildGate, ambient, runRecordCloseout = null, purchaseProof = null, brandContract = null, context = null, targetRepo = null }) {
+export function buildNextActions({ result, packetPath, packet, themeGate, polishGate, polishCheckpointGate, prepareBuildGate, ambient, runRecordCloseout = null, purchaseProof = null, brandContract = null, context = null, targetRepo = null, spec = null }) {
   const actions = [];
   const push = (id, kind, command, description, extras = {}) => actions.push({ id, kind, command, description, stage: result.stage, ...extras });
   const pushPolishCheckpointActions = () => {
@@ -4541,6 +4757,11 @@ export function buildNextActions({ result, packetPath, packet, themeGate, polish
     push(inspect.id, inspect.kind, asInvocation(inspect.command), inspect.description, { required: inspect.required });
     return actions;
   }
+  for (const subcommand of inputRefreshCommands(result.input_currency)) {
+    push("refresh_inputs", "command", `${cmd("record")} ${subcommand} --packet ${shellToken(packetPath)} --json`, subcommand === "brief"
+      ? "A recorded stage was made against earlier Campaign Build Brief content: save the brief with record brief (keeps stage history), then re-run next."
+      : "A recorded stage was made against earlier CampaignSpec content: bind it with record spec (keeps stage history), then re-run next.");
+  }
   if (result.stage === "doctor-blocked") {
     const checkpointGates = (result.gates || []).filter(
       (gate) => gate?.status === "blocked" && Object.hasOwn(CHECKPOINT_EVALUATORS, gate?.id || ""),
@@ -4637,9 +4858,10 @@ export function buildNextActions({ result, packetPath, packet, themeGate, polish
   if (result.stage === "setup") {
     push("setup_skill", "skill", "next-campaigns-os-setup", `Prepare the target page-kit structure and agent context, then record setup with ${cmd("record")} setup --packet ${packetPath}.`);
   } else if (result.stage === "build") {
-    push("build_skill", "skill", "next-campaigns-build", `Assemble the campaign per the build prompt, run the page-kit build, then record build with ${cmd("record")} build --packet ${packetPath}.`);
+    const recordBuild = `${cmd("record")} build --packet ${packetPath}${isLocalServePacket(packet) ? ` --build-environment ${LOCAL_PROOF_BUILD_ENVIRONMENT}` : ""}`;
+    push("build_skill", "skill", "next-campaigns-build", `Assemble the campaign per the build prompt, run the page-kit build, then record build with ${recordBuild}.`);
     if (isLocalServePacket(packet)) {
-      push("build_local_proof", "command", LOCAL_PROOF_BUILD_COMMAND, `Local proof mode (deploy.target is local-serve): build page-kit in the ${LOCAL_PROOF_BUILD_ENVIRONMENT} environment into _site/ and record ${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} as "${LOCAL_PROOF_BUILD_ENVIRONMENT}". Vendor loaders are environment-gated out of this render (their protocol-relative //host/... URLs fail over a plain-HTTP local serve); SDK dl_* events still fire. ${LOCAL_PROOF_NEVER_EDIT_RULE}`);
+      push("build_local_proof", "command", LOCAL_PROOF_BUILD_COMMAND, `Local proof mode (deploy.target is local-serve): build page-kit in the ${LOCAL_PROOF_BUILD_ENVIRONMENT} environment into _site/, then record it with ${recordBuild}, which sets ${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} to "${LOCAL_PROOF_BUILD_ENVIRONMENT}" (never hand-edit it). Vendor loaders are environment-gated out of this render (their protocol-relative //host/... URLs fail over a plain-HTTP local serve); SDK dl_* events still fire. ${LOCAL_PROOF_NEVER_EDIT_RULE}`);
       push("build_production_parity", "command", asInvocation(substitutePacket(LOCAL_PROOF_PARITY_COMMAND, packetPath)), "After the development build is proven, assert the production render differs from it only in environment-gated output (same pages, route slugs, Campaign Cart pin and next-api-key) before committing; the PR preview is the second check.");
     }
     if (themeGate?.status === "blocked") {
@@ -4661,7 +4883,9 @@ export function buildNextActions({ result, packetPath, packet, themeGate, polish
   } else if (result.stage === "qa") {
     const url = packet.deploy?.preview_url || packet.deploy?.production_url || "<preview-url>";
     push("install_browser", "command", `${cmd("qa")} install-browser`, "Install the Playwright browser once after install/update (npm run qa:install-browser from a checkout).");
-    push("qa_run", "command", `${cmd("qa")} run --packet ${packetPath} --base-url ${url} --browser --test-order common`, "Run browser + typed-card QA and publish the verdict.");
+    push("qa_run", "command", qaRunCommand(packetPath, url), "Run browser + typed-card QA and publish the verdict.");
+    const bumpCart = checkoutOrderBumpCart(spec);
+    if (bumpCart) push("qa_run_bump", "command", qaRunCommand(packetPath, url, bumpCart), `Prove the charged add-on. ${orderBumpRunReason(bumpCart)}`);
   } else if (result.stage === "done") {
     // #171: run-record closeout is a REQUIRED terminal action, not an
     // optional nicety — the dogfood run ended at a terminal stage with the
@@ -4789,9 +5013,9 @@ function templateStockPromptLine(packet, derived = {}) {
   return `\n- Template-stock pages (declared out of source scope; no design source exists for them): ${pages.join(", ")}. Keep these routes unbuilt by default, especially presell/landing pages staying on another host; never publish stock placeholder copy to fill a partial build. Materialise a page only with explicit operator opt-in for that page (including a pre-checkout select stand-in required by the runtime). For opted-in pages, use the ${packet.assembly.template_family} family's own page for that role with its dependent _includes, _layouts, and assets, wire it from CampaignSpec, and build a required select step first. Once its built HTML exists, doctor lists it among the previewable routes.`;
 }
 
-function buildPrompt(packetPath, contextPath, reportPath, packet, derived = {}) {
+function buildPrompt(packetPath, contextPath, reportPath, packet, derived = {}, intent) {
   const briefPath = packet.build_brief?.normalized_path || "(missing; generate or confirm Campaign Build Brief before business-sensitive assembly)";
-  return `Use next-campaigns-build for this Campaigns OS handoff.
+  return `${campaignIntentPromptHeader(intent)}Use next-campaigns-build for this Campaigns OS handoff.
 
 Read first:
 - Build Packet: ${packetPath}
@@ -4803,7 +5027,8 @@ Read first:
 
 Rules:
 - Treat CampaignSpec/API as the source for package, shipping, voucher, payment, tracking, footer, and SEO values.
-- Treat the Campaign Build Brief as the merchandising/design presentation truth: page authority, palette/CTA style, variant media rules, pricing display strategy, promo/urgency language, payment/trust surfaces, display-name policy, residue policy, and QA expectations. Agents may resolve implementation uncertainty; unresolved brief questions are business uncertainty and should be asked or recorded, not guessed.
+- Treat the Campaign Build Brief as the merchandising/design presentation truth: page authority, palette/CTA style, variant media rules, pricing display strategy, the template's own promo placeholders, payment/trust surfaces, display-name policy, residue policy, and QA expectations. Agents may resolve implementation uncertainty; unresolved brief questions are business uncertainty and should be asked or recorded, not guessed.
+- Refresh a changed Campaign Build Brief with \`${cmd("record")} brief --packet ${packetPath}\` and a changed CampaignSpec with \`${cmd("record")} spec --packet ${packetPath}\` before building on the change.
 - Read the selected template family's agentContract and sharedFrontmatterVocabulary before commerce wiring.
 - Prepared AI/exported HTML must be converted into page-kit-ready source first: keep page-owned body markup, strip document wrappers, add YAML frontmatter, move shared CSS/assets into the campaign structure, and use Liquid helpers only for page-kit links/assets/includes. Page Kit publishes src/<slug>/assets/config.js as /<slug>/config.js and src/<slug>/assets/products/foo.png as /<slug>/products/foo.png; do not leave raw /assets/... or /<slug>/assets/... references in rendered pages.
 - Preserve prepared source HTML for landing/presell pages when it is a real standalone design.
@@ -4817,22 +5042,57 @@ Rules:
 - Replace demo refs; do not copy Olympus-style shipping_methods into shop-three-step.
 - For two-step package-selection flows, treat the selector page as the pre-checkout step and pass the selected cart to checkout with forcePackageId; preserve normal tracking params and strip forcePackageId from visible checkout URLs after SDK initialization.
 - After page-kit build, inspect rendered _site output before handoff: each active page should have a body, Campaign Cart runtime markers, SDK meta tags from CampaignSpec sdk_hints.meta_tags, and no stale copied funnel attribution.
-- Run page-kit build and SDK/template lint, then record build before polish: \`${cmd("record")} build --packet ${packetPath}\`. It stamps stages.assembly.build_fingerprint with the fingerprint doctor computes from the built output (derived.build_output_fingerprint.value, sha256 over the sorted path+sha256 manifest of _site/<slug>/; doctor reports built_output.fingerprint_stale whenever the output on disk stops matching the recorded value), records report.design_source_package.material_fingerprint on stages.assembly.source_package_material_fingerprint when present, and sets stages.polish to "required" (required_by="build", required_for=["qa"]). Re-run it after every rebuild; never hand-edit these fields. Build must not mark stages.polish as completed/completed_with_warnings/skipped. If you applied a brand theme, run \`${cmd("record")} theme --packet ${packetPath}\` after record build: it reads each built commerce page's stylesheet links and records report.theme (status applied, load_order=after-next-core, css_path, commerce_pages, evidence), and refuses, writing nothing, when a page that loads next-core.css does not load the brand layer after it. Never hand-edit report.theme.
-- Capture the machine-readable build summary as an artifact: \`${PAGE_KIT_BUILD_SUMMARY_CAPTURE_COMMAND}\` (requires next-campaign-page-kit >= 0.1.4). Doctor verifies it for per-page build errors and Page Kit shape warnings (NESTED_NO_PERMALINK, DUPLICATE_OUTPUT, MISSING_FRONTMATTER, LAYOUT_NOT_FOUND). If the installed page-kit predates --json, record that in the assembly report instead of skipping silently.${localProofPromptLines(packet)}`;
+- Run page-kit build and SDK/template lint, then record build before polish: \`${cmd("record")} build --packet ${packetPath}${isLocalServePacket(packet) ? ` --build-environment ${LOCAL_PROOF_BUILD_ENVIRONMENT}` : ""}\`. It stamps stages.assembly.build_fingerprint with the fingerprint doctor computes from the built output (derived.build_output_fingerprint.value, sha256 over the sorted path+sha256 manifest of _site/<slug>/; doctor reports built_output.fingerprint_stale whenever the output on disk stops matching the recorded value), records report.design_source_package.material_fingerprint on stages.assembly.source_package_material_fingerprint when present, and sets stages.polish to "required" (required_by="build", required_for=["qa"]). Re-run it after every rebuild; never hand-edit these fields. Build must not mark stages.polish as completed/completed_with_warnings/skipped. If you applied a brand theme, run \`${cmd("record")} theme --packet ${packetPath}\` after record build: it reads each built commerce page's stylesheet links and records report.theme (status applied, load_order=after-next-core, css_path, commerce_pages, evidence), and refuses, writing nothing, when a page that loads next-core.css does not load the brand layer after it. Never hand-edit report.theme.
+- Capture the machine-readable build summary as an artifact: \`${PAGE_KIT_BUILD_SUMMARY_CAPTURE_COMMAND}\` (requires next-campaign-page-kit >= 0.1.4). Doctor verifies it for per-page build errors and Page Kit shape warnings (NESTED_NO_PERMALINK, DUPLICATE_OUTPUT, MISSING_FRONTMATTER, LAYOUT_NOT_FOUND). If the installed page-kit predates --json, record that in the assembly report instead of skipping silently.${localProofPromptLines(packet, packetPath)}`;
 }
 
 // Local proof mode lines for the build prompt: under local-serve the build is
 // the development render, recorded as such, and the production render is
 // proven by parity before commit.
-function localProofPromptLines(packet) {
+function localProofPromptLines(packet, packetPath = "<packet>") {
   if (!isLocalServePacket(packet)) return "";
   return `
-- Local proof mode (deploy.target is local-serve): run the page-kit build in the ${LOCAL_PROOF_BUILD_ENVIRONMENT} environment — \`${LOCAL_PROOF_BUILD_COMMAND}\` — so _site/ is the development render, and record ${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} as "${LOCAL_PROOF_BUILD_ENVIRONMENT}" on the assembly report. The starter templates gate every vendor loader on the environment and several loaders are protocol-relative (//host/...), which fail over a plain-HTTP local serve; the SDK's dl_* events still fire in development. Polish capture, browser QA and typed-card orders run against this served output. Before committing, run \`${asInvocation(LOCAL_PROOF_PARITY_COMMAND)}\` to prove the production render differs only in environment-gated output and pins the same Campaign Cart version; the PR preview is the second check. ${LOCAL_PROOF_NEVER_EDIT_RULE}`;
+- Local proof mode (deploy.target is local-serve): run the page-kit build in the ${LOCAL_PROOF_BUILD_ENVIRONMENT} environment — \`${LOCAL_PROOF_BUILD_COMMAND}\` — so _site/ is the development render, and record it with \`${cmd("record")} build --packet ${packetPath} --build-environment ${LOCAL_PROOF_BUILD_ENVIRONMENT}\`, which sets ${LOCAL_PROOF_BUILD_ENVIRONMENT_FIELD} to "${LOCAL_PROOF_BUILD_ENVIRONMENT}" on the assembly report (never hand-edit it). The starter templates gate every vendor loader on the environment and several loaders are protocol-relative (//host/...), which fail over a plain-HTTP local serve; the SDK's dl_* events still fire in development. Polish capture, browser QA and typed-card orders run against this served output. Before committing, run \`${asInvocation(LOCAL_PROOF_PARITY_COMMAND)}\` to prove the production render differs only in environment-gated output and pins the same Campaign Cart version; the PR preview is the second check. ${LOCAL_PROOF_NEVER_EDIT_RULE}`;
+}
+
+// Read the normalized brief the packet records, resolved against the packet
+// file as doctor resolves it, and summarize it over the Build Context's active
+// pages in recorded order. A missing, unreadable or invalid brief reads
+// unavailable; this never fails `next`. Each read or summarising failure is
+// named on stderr, one line per failure, never on stdout.
+function readIntentSummary(packetPath, packet, contextPath) {
+  const reportFailure = (error) => process.stderr.write(`campaigns-os: intent summary unavailable: ${singleLineFragment(error?.message ?? error, "unknown error")}\n`);
+  const normalizedPath = resolveFromFile(packetPath, packet?.build_brief?.normalized_path);
+  let brief = null;
+  try {
+    brief = readJsonIfExists(normalizedPath);
+  } catch (error) {
+    reportFailure(error);
+    brief = null;
+  }
+  let activePageIds = [];
+  try {
+    const activePages = readJsonIfExists(contextPath)?.spec?.active_pages;
+    activePageIds = Array.isArray(activePages) ? activePages.map((page) => page?.id) : [];
+  } catch (error) {
+    reportFailure(error);
+    activePageIds = [];
+  }
+  return { ...summarizeCampaignBrief({ brief, activePageIds, onError: reportFailure }), normalized_path: normalizedPath };
+}
+
+// The setup, build, Polish and QA prompts start with the campaign intent
+// summary, framed as orientation only.
+function campaignIntentPromptHeader(intent) {
+  return `Campaign intent (from the Campaign Build Brief at ${intent.normalized_path || "(not recorded)"}; orientation only, never a source of prices or commerce behaviour):
+${intent.text}
+
+`;
 }
 
-function setupPrompt(packetPath, contextPath, reportPath, packet) {
+function setupPrompt(packetPath, contextPath, reportPath, packet, intent) {
   const briefPath = packet.build_brief?.normalized_path || "(missing)";
-  return `Use next-campaigns-os-setup for this Campaigns OS handoff.
+  return `${campaignIntentPromptHeader(intent)}Use next-campaigns-os-setup for this Campaigns OS handoff.
 
 Read first:
 - Build Packet: ${packetPath}
@@ -4851,9 +5111,9 @@ When copying a starter template family, copy the family as an atomic page-kit sl
 Do not wire checkout, upsell, receipt, payment, package, voucher, or shipping behavior during setup.`;
 }
 
-function polishPrompt(packetPath, reportPath, packet) {
+function polishPrompt(packetPath, reportPath, packet, intent) {
   const briefPath = packet.build_brief?.normalized_path || "(missing)";
-  return `Use next-campaigns-polish for this built campaign.
+  return `${campaignIntentPromptHeader(intent)}Use next-campaigns-polish for this built campaign.
 
 Read first:
 - Build Packet: ${packetPath}
@@ -4952,10 +5212,58 @@ After deploy succeeds:
 If the deploy is blocked (non-localhost allowed-domain not yet added, CI permission missing, host-side outage), set stages.deploy.status to "blocked" with a clear reason in outputs so the orchestration loop surfaces it rather than skipping past.`;
 }
 
-function qaPrompt(packetPath, reportPath, packet) {
+// The QA command the QA stage hands over. Given a bump cart it is the
+// order-bump run: the same command with --cart selecting the base tier and
+// toggling each declared bump.
+function qaRunCommand(packetPath, url, bumpCart = null) {
+  return `${cmd("qa")} run --packet ${packetPath} --base-url ${url} --browser --test-order common${bumpCart ? ` --cart ${shellToken(bumpCart.cart)}` : ""}`;
+}
+
+// `qa run --test-order common` never puts a checkout order bump in a test
+// order: the tier planner skips bump rows by design and bump coverage comes
+// from --cart. So when the spec declares one, `next` names a second run with
+// the bump in the cart. It reads the one checkout QA drives, with QA's own row
+// classifiers: QA's test orders run on findPage(topologies, "checkout"), the
+// first checkout across funnels in array order, each funnel's pages filtered
+// to enabled and sorted by `order || 0` (extractTopologies). This picks the
+// same page, and when that checkout declares no bump it returns null rather
+// than looking at a later funnel: QA never drives a later funnel's checkout,
+// so that funnel's bump ref in --cart would land on a checkout without it. The base is the first selector tier QA would plan: QA's default
+// keeps the page's pre-selected card, which a spec does not name. A checkout
+// that declares no tier (the cart is filled on an entry page) gets the bump
+// alone, on whatever selection the entry page made.
+export function checkoutOrderBumpCart(spec) {
+  const funnels = Array.isArray(spec?.funnels)
+    ? spec.funnels
+    : Array.isArray(spec?.funnel_pages) ? [{ pages: spec.funnel_pages }] : [];
+  for (const funnel of funnels) {
+    const checkout = (Array.isArray(funnel?.pages) ? funnel.pages : [])
+      .filter((page) => page && page.enabled !== false)
+      .sort((a, b) => (a.order || 0) - (b.order || 0))
+      .find((page) => page.type === "checkout");
+    if (!checkout) continue;
+    const bumps = declaredOrderBumps(checkout);
+    if (!bumps.length) return null;
+    const base = declaredSelectorTiers(checkout)[0]?.ref || null;
+    return { base, bumps, cart: [base, ...bumps].filter(Boolean).map((ref) => `${ref}:1`).join(",") };
+  }
+  return null;
+}
+
+// Why the order-bump run exists, as one sentence for the action and the prompt.
+function orderBumpRunReason(bumpCart) {
+  const cart = bumpCart.base ? `base tier ${bumpCart.base} plus the bump` : "the bump";
+  return `The checkout declares order bump ${bumpCart.bumps.join(", ")} (is_order_bump or is_upsell), and the default run never puts it in a test order. This run repeats QA with ${cart} in the cart.`;
+}
+
+function qaPrompt(packetPath, reportPath, packet, spec = null, intent) {
   const url = packet.deploy?.preview_url || packet.deploy?.production_url || "<preview-url>";
   const briefPath = packet.build_brief?.normalized_path || "(missing)";
-  return `Use next-campaigns-qa for this deployed campaign.
+  const bumpCart = checkoutOrderBumpCart(spec);
+  const bumpCommand = bumpCart
+    ? `\n\nOrder bump QA command (proves the charged add-on):\n${qaRunCommand(packetPath, url, bumpCart)}\n${orderBumpRunReason(bumpCart)}`
+    : "";
+  return `${campaignIntentPromptHeader(intent)}Use next-campaigns-qa for this deployed campaign.
 
 ${packet.spec.local_spec_id ? "Local spec ID" : "Map ID"}: ${packet.spec.local_spec_id || packet.spec.map_id}
 Base URL: ${url}
@@ -4966,9 +5274,9 @@ Browser install command:
 ${cmd("qa")} install-browser
 
 Node QA command:
-${cmd("qa")} run --packet ${packetPath} --base-url ${url} --browser --test-order common
+${qaRunCommand(packetPath, url)}${bumpCommand}
 
-Run the browser install once after install/update before --browser or --test-order. Test-order proof must exercise the campaign through the Campaign Cart SDK with the browser typed-card flow. Do not create hand-built backend API orders as launch proof. Compare visible placeholders, payment methods, variant media, promo/urgency copy, pricing presentation, and trust/guarantee claims against the Campaign Build Brief. Test Orders use global test cards that bypass the payment gateway and create no transactions, so they are safe to run any time and need no permission flags, packet policy, or merchant setup. Localhost on any port is a globally allowed Development domain for SDK initialization and suppresses Campaigns analytics events; non-localhost preview/production origins still need the SDK origin allowlist. Use --test-order common for the default depth: every actual terminal path when they fit under the flood cap, otherwise checkout, first-offer accept/decline and a deduplicated shortest real receipt path plus the shortest path that clicks the decline on each offer or downsell page not yet declined, up to the cap (the verdict row browser-test-order:upsell-action-coverage warns naming each offer page whose decline no order clicked); use an explicit path such as accept-decline-accept for a targeted matrix; or use --test-order full for every actual terminal path in the selected checkout topology. Cycles, missing routes, and reachable nonterminals block exhaustive proof before browser launch. The default accidental-flood cap is 6, and an overflow names the exact explicit --max-test-orders raise. That cap bounds planned paths; --max-order-creations bounds actual order creations and is reserved before each submit click, defaulting to the planned path count. A path whose failure is classified as created (the order is already placed) is inspected read-only and never resubmitted. A not_created failure may be re-run once, if the creation budget has a slot no still-unrun planned path needs; an ambiguous failure stops that path with an explicit operator check instead of buying again. Read evidence.recovery to tell a recovered pass from a first-attempt pass. Click rendered SDK upsell accept/decline controls for upsell proof. For multi-tier package selectors, drive a specific card with --select-package <ref[:qty],...> (strict: the path fails if the requested card cannot be found or selected, unlike best-effort --cart), or use --test-order tiers / tiers:common / tiers:full to drive every selector tier the CampaignSpec declares on the checkout page in one run (order-bump rows marked is_upsell are add-ons, not tiers; --select-package narrows a tiers run to the listed tiers); prove coupon-bearing orders with --apply-coupon <code> (typed into the rendered promo input, verified against the persisted-order voucher read-back). Reuse one test customer email via --test-email or CAMPAIGNS_OS_QA_TEST_EMAIL (a real monitored inbox in internal runs) so repeated QA does not litter the customer list.
+Run the browser install once after install/update before --browser or --test-order. Test-order proof must exercise the campaign through the Campaign Cart SDK with the browser typed-card flow. Do not create hand-built backend API orders as launch proof. Compare visible placeholders, payment methods and template trust badges, variant media, the template's own promo placeholders (demo timers, promo banners, placeholder voucher codes, exit-pop offers), and pricing presentation against the Campaign Build Brief. Do not flag the source design's own proof, urgency or guarantee elements: they are the merchant's content. Test Orders use global test cards that bypass the payment gateway and create no transactions, so they are safe to run any time and need no permission flags, packet policy, or merchant setup. Localhost on any port is a globally allowed Development domain for SDK initialization and suppresses Campaigns analytics events; non-localhost preview/production origins still need the SDK origin allowlist. Use --test-order common for the default depth: every actual terminal path when they fit under the flood cap, otherwise checkout, first-offer accept/decline and a deduplicated shortest real receipt path plus the shortest path that clicks the decline on each offer or downsell page not yet declined, up to the cap (the verdict row browser-test-order:upsell-action-coverage warns naming each offer page whose decline no order clicked); use an explicit path such as accept-decline-accept for a targeted matrix; or use --test-order full for every actual terminal path in the selected checkout topology. Cycles, missing routes, and reachable nonterminals block exhaustive proof before browser launch. The default accidental-flood cap is 6, and an overflow names the exact explicit --max-test-orders raise. That cap bounds planned paths; --max-order-creations bounds actual order creations and is reserved before each submit click, defaulting to the planned path count. A path whose failure is classified as created (the order is already placed) is inspected read-only and never resubmitted. A not_created failure may be re-run once, if the creation budget has a slot no still-unrun planned path needs; an ambiguous failure stops that path with an explicit operator check instead of buying again. Read evidence.recovery to tell a recovered pass from a first-attempt pass. Click rendered SDK upsell accept/decline controls for upsell proof. For multi-tier package selectors, drive a specific card with --select-package <ref[:qty],...> (strict: the path fails if the requested card cannot be found or selected, unlike best-effort --cart), or use --test-order tiers / tiers:common / tiers:full to drive every selector tier the CampaignSpec declares on the checkout page in one run (order-bump rows marked is_order_bump or is_upsell are add-ons, not tiers; --select-package narrows a tiers run to the listed tiers); prove coupon-bearing orders with --apply-coupon <code> (typed into the rendered promo input, verified against the persisted-order voucher read-back). Reuse one test customer email via --test-email or CAMPAIGNS_OS_QA_TEST_EMAIL (a real monitored inbox in internal runs) so repeated QA does not litter the customer list.
 
 Launch readiness note: Campaigns OS can prove the campaign build, SDK wiring, browser behavior, and typed-card order paths. It does not prove the merchant is ready for real shoppers. Before launch, confirm the production storefront URL, live payment methods, shipping markets, legal/support URLs, analytics expectations, and any merchant-side configuration. Treat those as real-shopper readiness items, not Campaigns OS build blockers.
 
@@ -5800,7 +6108,8 @@ export async function toolingStatusCommand(args, options = {}) {
   const auth = result.gateway_login;
   if (!auth.accounts.length) result.warnings.push(auth.state === "unavailable"
     ? "Gateway credential storage is unavailable or busy. Check user credential directory permissions and keychain access; wait for another campaigns-os process to finish. See docs/gateway-login.md for interrupted-process recovery."
-    : `Gateway login: ${auth.state}. Use ${result.cli.invocation_prefix} login --store <subdomain>.`);
+    : `Gateway login: ${auth.state}. Optional: ${result.cli.invocation_prefix} login --store <subdomain> only lets spec derive --from-store fill the Store Profile fields (campaign.store_*).`);
+  if (!auth.accounts.length && auth.state !== "unavailable") result.warnings.push(`Package, offer and shipping refs never come from the gateway login: read them with the campaign's public Campaigns API key (docs/build-packet.md, "Reading package, offer and shipping refs").`);
   for (const account of auth.accounts) (account.state === "logged_in" ? result.ready : result.warnings).push(`Gateway login: ${account.state}; store ${account.store}; access remaining ${account.remaining_seconds}s; gateway ${auth.gateway}; reported version ${account.gateway_version || "unavailable"} (local credential metadata only).`);
   return result;
 }
@@ -6128,7 +6437,7 @@ function safePolishByteCount(value) {
 }
 
 export function formatPolishCaptureText(result) {
-  const status = ["ready", "ready_with_waivers", "blocked"].includes(result?.status)
+  const status = ["ready", "ready_with_waivers", "captured_with_warnings", "blocked"].includes(result?.status)
     ? result.status
     : "unknown";
   const measurementStatus = ["complete", "incomplete"].includes(result?.measurement?.status)
@@ -6142,6 +6451,11 @@ export function formatPolishCaptureText(result) {
     `Status: ${status.toUpperCase()}`,
     `Measurement: ${measurementStatus.toUpperCase()}`,
   ];
+  // Outcomes that did not stop the capture, printed with their own message
+  // (the held page-load plan message on a campaign with no mapped pages).
+  for (const warning of Array.isArray(result?.warnings) ? result.warnings : []) {
+    if (warning?.code === "no_capturable_routes" && typeof warning.message === "string") lines.push(`Warning: ${warning.message}`);
+  }
   const incomplete = Array.isArray(result?.measurement?.incomplete)
     ? result.measurement.incomplete
     : [];
@@ -8038,6 +8352,8 @@ export function nextTinyPromptLines(result) {
   if (result.stage !== "qa") return lines;
   lines.push("");
   lines.push(`Next expected proof: browser QA + typed-card proof. Run: ${cmd("qa")} run --packet <packet> --base-url <url> --browser --test-order common`);
+  const bumpRun = (result.next_actions || []).find((action) => action?.id === "qa_run_bump");
+  if (bumpRun) lines.push(`That run never orders the checkout order bump. Prove the charged add-on with: ${bumpRun.command}`);
   lines.push("Localhost on any port is a Development domain (SDK allowed, analytics suppressed). Non-localhost origins still need SDK allowlist confirmation.");
   lines.push(`Build/polish done but no QA verdict yet is a Completeness Signal, not a build failure: ${cmd("findings")} add --stage qa --kind missing_prompt --summary "..."`);
   return lines;
@@ -8141,6 +8457,8 @@ const WAIVE_ACTIONS = new Set(["theme-waive", "checkpoint-waive"]);
 // check's readiness line); they are text-only and never enter the JSON result.
 export function resultTextLines(result, { headerLines = [] } = {}) {
   const lines = [`Status: ${String(result.status || "unknown").toUpperCase()}`, ...headerLines];
+  // `next` only: the campaign intent summary, directly under the status.
+  if (result.intent_summary) lines.push("Campaign intent:", ...result.intent_summary.text.split("\n"));
   // A waive command's second line names what it recorded; the third is the
   // stage doctor now picks for the report the waiver was written to.
   if (WAIVE_ACTIONS.has(result.action) && result.gate) {
@@ -8148,6 +8466,10 @@ export function resultTextLines(result, { headerLines = [] } = {}) {
     if (result.dry_run) lines.push(`Would write: ${result.would_write} (nothing was written)`);
     if (result.next_stage) lines.push(`Next stage: ${result.next_stage}${result.next_stage_reason ? ` (${result.next_stage_reason})` : ""}`);
   }
+  if (result.action === "checkpoint-accept") {
+    for (const accept of result.accepts || []) lines.push(`${result.dry_run ? "Would accept" : "Accepted"}: ${accept.result_ref} by ${accept.accepted_by}${accept.expires_at ? ` until ${accept.expires_at}` : ""}`);
+    if (result.dry_run) lines.push(`Would write: ${result.would_write} (nothing was written)`);
+  }
   if (result.action === "record") {
     lines.push(`${result.dry_run ? "Would record" : "Recorded"}: ${result.stage}`);
     for (const path of result.dry_run ? result.would_write : result.written) lines.push(`${result.dry_run ? "Would write" : "Wrote"}: ${path}${result.dry_run ? " (nothing was written)" : ""}`);
@@ -8189,6 +8511,8 @@ export function resultTextLines(result, { headerLines = [] } = {}) {
   // Directly under the findings they remediate, above the stage picker's
   // `Next:` block: the operator reads what is wrong, then what clears it.
   lines.push(...doctorRequiredActionLines(result));
+  // `next` only: the QC handoff, after the issues and before the stage picker.
+  if (result.qc_handoff) lines.push(...qcHandoffTextLines(result.qc_handoff));
   if (result.next) {
     lines.push("Next:");
     lines.push(`- ${result.next.stage || "unknown"} (${result.next.owner || result.next.default_skill || "owner unknown"})`);