stylegallery 0.1.0

package/consumer-reference/fixtures/consumer-conformance/e2e-fixture.mjs

@@ -0,0 +1,282 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { canonicalSourceManifest, digest } from "../../../scripts/page-evidence-contract.mjs";
+import {
+  cleanupFixture,
+  finalizeSession,
+  initializeConsumer,
+  startSession,
+  writeJson,
+  writeRunner,
+} from "../../../scripts/page-evidence-fixture.mjs";
+
+const styleGalleryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
+const validator = path.join(styleGalleryRoot, "scripts", "validate-consumer-conformance.mjs");
+
+function runValidator(root, record, { artifactRoot, priorManifest } = {}) {
+  const args = [validator, "--root", root, "--record", record];
+  if (artifactRoot) args.push("--artifact-root", artifactRoot);
+  if (priorManifest) args.push("--prior-manifest", priorManifest);
+  args.push("--json");
+  const child = spawnSync(process.execPath, args, { cwd: styleGalleryRoot, encoding: "utf8" });
+  let output;
+  try { output = JSON.parse(child.stdout); }
+  catch { output = { failures: [], parse_error: child.stderr || child.stdout }; }
+  return { output, status: child.status };
+}
+
+function codes(child) {
+  return child?.report?.failures?.map((entry) => entry.code)
+    ?? child?.output?.failures?.map((entry) => entry.code)
+    ?? [];
+}
+
+function outcome(name, expected, child, observe = {}) {
+  const actualCodes = codes(child);
+  const childOk = expected === "ok:true"
+    ? child?.status === 0 && (child.report?.ok === true || child.output?.ok === true)
+    : child?.status !== 0 && actualCodes.includes(expected);
+  const ok = childOk && !Object.values(observe).includes(false);
+  return { actual: { codes: actualCodes, status: child?.status, ...observe }, expected, name, ok };
+}
+
+function sourceManifest(fixture) {
+  const failures = [];
+  const source = canonicalSourceManifest(fixture.root, fixture.relevantSources, failures);
+  if (!source || failures.length > 0) throw new Error(`source fixture failed: ${JSON.stringify(failures)}`);
+  return source;
+}
+
+function createSession(fixture, template, options = {}) {
+  const artifactName = options.artifactName ?? "migration";
+  const scenarioId = options.scenarioId ?? "migration-round-trip";
+  const session = {
+    artifactRoot: path.join(fixture.root, "evidence", artifactName),
+    handoffFile: path.join(fixture.root, "records", `${artifactName}-handoff.json`),
+    recordFile: path.join(fixture.root, "records", `${artifactName}.json`),
+    runId: options.runId ?? `run-${artifactName}`,
+    scenarioId,
+    sessionId: options.sessionId ?? `session-${artifactName}`,
+  };
+  const value = structuredClone(template);
+  const styleGalleryRevision = execFileSync("git", ["rev-parse", "HEAD"], { cwd: styleGalleryRoot, encoding: "utf8" }).trim();
+  value.id = `${artifactName}-migration`;
+  value.consumer = { relevant_sources: fixture.relevantSources, repository: fixture.repository, revision: fixture.revision };
+  value.page_evidence = { manifest: `evidence/${artifactName}/page-evidence-manifest.json`, status: "applicable" };
+  value.scenarios[0] = {
+    ...value.scenarios[0],
+    argv: ["node", "tests/page.spec.js"],
+    evidence_method: "browser",
+    id: scenarioId,
+    result_artifact: `evidence/${artifactName}/runner/${scenarioId}.json`,
+    run_id: session.runId,
+    session_id: session.sessionId,
+    source_digest: sourceManifest(fixture).sha256,
+  };
+  for (const dimension of Object.values(value.migration_dimensions)) if (dimension.status === "applicable") dimension.scenario_ids = [scenarioId];
+  for (const mapping of value.adoption_mappings) {
+    mapping.scenario_ids = [scenarioId];
+    mapping.stylegallery.revision = styleGalleryRevision;
+  }
+  options.mutateRecord?.(value);
+  writeJson(session.recordFile, value);
+  writeJson(session.handoffFile, { consumer_conformance_record: `records/${artifactName}.json`, consumer_migration_readiness: "declared" });
+  return session;
+}
+
+function startedSession(fixture, template, options) {
+  const session = createSession(fixture, template, options);
+  const start = startSession(fixture, session);
+  if (start.status !== 0) throw new Error(`session start failed: ${JSON.stringify(start.report)}`);
+  return session;
+}
+
+function isolated(template, run) {
+  const fixture = initializeConsumer();
+  try { return run(fixture, template); }
+  finally { cleanupFixture(fixture); }
+}
+
+export function initializeCompletedConsumer(template) {
+  const fixture = initializeConsumer();
+  try {
+    const session = startedSession(fixture, template);
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    return { ...fixture, artifactRoot: session.artifactRoot, recordReference: "records/migration.json" };
+  } catch (error) {
+    cleanupFixture(fixture);
+    throw error;
+  }
+}
+
+export function cleanupCompletedConsumer(fixture) {
+  cleanupFixture(fixture);
+}
+
+function mutatedCompletedPacket(template, { caseName, expected, mutateRecord }) {
+  return isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source, { artifactName: caseName });
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    const value = JSON.parse(fs.readFileSync(session.recordFile, "utf8"));
+    mutateRecord(value);
+    writeJson(session.recordFile, value);
+    return outcome(caseName, expected, runValidator(fixture.root, `records/${caseName}.json`, { artifactRoot: session.artifactRoot }));
+  });
+}
+
+const cases = {
+  "end-to-end-consumer": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source);
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    const handoff = JSON.parse(fs.readFileSync(session.handoffFile, "utf8"));
+    const child = runValidator(fixture.root, handoff.consumer_conformance_record, { artifactRoot: session.artifactRoot });
+    return outcome("end-to-end-consumer", "ok:true", child, {
+      artifactRootOutsideStyleGallery: !session.artifactRoot.startsWith(styleGalleryRoot),
+      checkedDimensions: child.output.checkedDimensions,
+      checkedMappings: child.output.checkedMappings,
+      checkedPageArtifacts: child.output.checkedPageArtifacts,
+      checkedPageScenarios: child.output.checkedPageScenarios,
+      handoffLinked: handoff.consumer_migration_readiness === "declared" && handoff.consumer_conformance_record === "records/migration.json",
+      pageSessionId: child.output.pageSessionId,
+    });
+  }),
+  "missing-mapping": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source, { mutateRecord: (value) => {
+      const unit = { ...value.scenarios[0], evidence_method: "unit", id: "unit-migration", result_artifact: "evidence/results/unit-migration.json" };
+      value.scenarios.push(unit);
+      value.adoption_mappings[0].scenario_ids = [unit.id];
+    } });
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    return outcome("missing-mapping", "page_evidence_adoption_mapping_missing", runValidator(fixture.root, "records/migration.json", { artifactRoot: session.artifactRoot }));
+  }),
+  "applicable-without-runtime": (template) => isolated(template, (fixture, source) => {
+    const session = createSession(fixture, source, { mutateRecord: (value) => { value.scenarios[0].evidence_method = "unit"; } });
+    fs.mkdirSync(session.artifactRoot, { recursive: true });
+    return outcome("applicable-without-runtime", "page_evidence_runtime_scenario_required", runValidator(fixture.root, "records/migration.json", { artifactRoot: session.artifactRoot }));
+  }),
+  "dirty-source": (template) => isolated(template, (fixture, source) => {
+    const session = createSession(fixture, source);
+    fs.appendFileSync(path.join(fixture.root, fixture.relevantSources[0]), "// dirty\n");
+    return outcome("dirty-source", "page_evidence_source_dirty", startSession(fixture, session));
+  }),
+  "failed-runner": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source);
+    return outcome("failed-runner", "page_evidence_runner_failed", finalizeSession(fixture, session, writeRunner(fixture, session, { status: "failed" })));
+  }),
+  "cross-session-reuse": (template) => isolated(template, (fixture, source) => {
+    const target = startedSession(fixture, source, { artifactName: "target" });
+    const alternate = startedSession(fixture, source, { artifactName: "alternate" });
+    const targetRunner = writeRunner(fixture, target);
+    const alternateRunner = writeRunner(fixture, alternate);
+    fs.copyFileSync(alternateRunner.runnerFile, targetRunner.runnerFile);
+    fs.copyFileSync(path.join(alternate.artifactRoot, alternateRunner.artifactReference), path.join(target.artifactRoot, targetRunner.artifactReference));
+    return outcome("cross-session-reuse", "page_evidence_session_mismatch", finalizeSession(fixture, target, targetRunner));
+  }),
+  "unmanifested-artifact": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source);
+    const runner = writeRunner(fixture, session);
+    fs.writeFileSync(path.join(session.artifactRoot, "rogue.png"), "rogue");
+    return outcome("unmanifested-artifact", "page_evidence_artifact_unmanifested", finalizeSession(fixture, session, runner));
+  }),
+  "reuse-source-drift": (template) => isolated(template, (fixture, source) => {
+    const prior = startedSession(fixture, source, { artifactName: "prior" });
+    const priorFinalized = finalizeSession(fixture, prior, writeRunner(fixture, prior));
+    if (priorFinalized.status !== 0) throw new Error(`prior finalize failed: ${JSON.stringify(priorFinalized.report)}`);
+    fs.appendFileSync(path.join(fixture.root, fixture.relevantSources[0]), "// next revision\n");
+    execFileSync("git", ["add", fixture.relevantSources[0]], { cwd: fixture.root });
+    execFileSync("git", ["commit", "-m", "next fixture revision"], { cwd: fixture.root, stdio: "ignore" });
+    fixture.revision = execFileSync("git", ["rev-parse", "HEAD"], { cwd: fixture.root, encoding: "utf8" }).trim();
+    const current = startedSession(fixture, source, { artifactName: "current" });
+    const priorManifest = path.join(prior.artifactRoot, "page-evidence-manifest.json");
+    const evidence = {
+      kind: "reused",
+      prior_manifest_sha256: digest(fs.readFileSync(priorManifest)),
+      prior_run_id: prior.runId,
+      prior_scenario_id: prior.scenarioId,
+      prior_session_id: prior.sessionId,
+    };
+    const runner = writeRunner(fixture, current, { evidence, writeArtifact: false });
+    return outcome("reuse-source-drift", "page_evidence_reuse_source_mismatch", finalizeSession(fixture, current, runner, priorManifest));
+  }),
+  "source-set-mismatch": (template) => mutatedCompletedPacket(template, {
+    caseName: "source-set-mismatch",
+    expected: "page_evidence_source_set_mismatch",
+    mutateRecord: (value) => { value.consumer.relevant_sources = value.consumer.relevant_sources.slice(0, 1); },
+  }),
+  "repository-mismatch": (template) => mutatedCompletedPacket(template, {
+    caseName: "repository-mismatch",
+    expected: "page_evidence_repository_mismatch",
+    mutateRecord: (value) => { value.consumer.repository = "other/consumer"; },
+  }),
+  "revision-mismatch": (template) => mutatedCompletedPacket(template, {
+    caseName: "revision-mismatch",
+    expected: "page_evidence_revision_mismatch",
+    mutateRecord: (value) => { value.consumer.revision = "0".repeat(40); },
+  }),
+  "source-digest-mismatch": (template) => mutatedCompletedPacket(template, {
+    caseName: "source-digest-mismatch",
+    expected: "page_evidence_source_mismatch",
+    mutateRecord: (value) => { value.scenarios[0].source_digest = "0".repeat(64); },
+  }),
+  "intent-scenario-mismatch": (template) => mutatedCompletedPacket(template, {
+    caseName: "intent-scenario-mismatch",
+    expected: "page_evidence_intent_scenario_mismatch",
+    mutateRecord: (value) => {
+      const additional = { ...value.scenarios[0], id: "secondary-browser", result_artifact: "evidence/intent-scenario-mismatch/runner/secondary-browser.json" };
+      value.scenarios.push(additional);
+      value.migration_dimensions.route_parity.scenario_ids.push(additional.id);
+      value.adoption_mappings[0].scenario_ids.push(additional.id);
+    },
+  }),
+  "review-by-missing": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source, { artifactName: "review-by-missing" });
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    const manifestFile = path.join(session.artifactRoot, "page-evidence-manifest.json");
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+    delete manifest.review_by;
+    writeJson(manifestFile, manifest);
+    return outcome("review-by-missing", "page_evidence_manifest_schema_invalid", runValidator(fixture.root, "records/review-by-missing.json", { artifactRoot: session.artifactRoot }));
+  }),
+  "manifest-network-url": (template) => isolated(template, (fixture, source) => {
+    const session = createSession(fixture, source, { artifactName: "manifest-network-url", mutateRecord: (value) => {
+      value.page_evidence.manifest = "https://example.com/page-evidence-manifest.json";
+    } });
+    fs.mkdirSync(session.artifactRoot, { recursive: true });
+    const child = runValidator(fixture.root, "records/manifest-network-url.json", { artifactRoot: session.artifactRoot });
+    return outcome("manifest-network-url", "consumer_conformance_schema_invalid", child, {
+      noRuntimeExecution: child.output.checkedRuntimeCommands === 0,
+    });
+  }),
+  "manifest-symlink": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source, { artifactName: "manifest-symlink" });
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    const manifest = path.join(session.artifactRoot, "page-evidence-manifest.json");
+    const redirected = path.join(session.artifactRoot, "redirected-manifest.json");
+    fs.renameSync(manifest, redirected);
+    fs.symlinkSync(redirected, manifest);
+    return outcome("manifest-symlink", "page_evidence_manifest_symlink", runValidator(fixture.root, "records/manifest-symlink.json", { artifactRoot: session.artifactRoot }));
+  }),
+  "artifact-root-redirect": (template) => isolated(template, (fixture, source) => {
+    const session = startedSession(fixture, source, { artifactName: "artifact-root-redirect" });
+    const finalized = finalizeSession(fixture, session, writeRunner(fixture, session));
+    if (finalized.status !== 0) throw new Error(`session finalize failed: ${JSON.stringify(finalized.report)}`);
+    const redirected = `${session.artifactRoot}-redirected`;
+    fs.renameSync(session.artifactRoot, redirected);
+    fs.symlinkSync(redirected, session.artifactRoot);
+    return outcome("artifact-root-redirect", "page_evidence_artifact_symlink", runValidator(fixture.root, "records/artifact-root-redirect.json", { artifactRoot: session.artifactRoot }));
+  }),
+};
+
+export const endToEndCaseNames = Object.freeze(Object.keys(cases));
+
+export function runEndToEndCase(name, template) {
+  return cases[name](template);
+}

package/consumer-reference/fixtures/consumer-conformance/manifest.json

@@ -0,0 +1,102 @@
+{
+  "id": "consumer-conformance-fixture-inventory",
+  "invalid_cases": [
+    {
+      "expected_code": "migration_dimension_required",
+      "name": "omitted-dimension"
+    },
+    {
+      "expected_code": "migration_dimension_scenario_required",
+      "name": "applicable-without-scenario"
+    },
+    {
+      "expected_code": "runtime_evidence_method_invalid",
+      "name": "source-regex-runtime-proof"
+    },
+    {
+      "expected_code": "adoption_scenario_unknown",
+      "name": "orphan-adoption-scenario"
+    },
+    {
+      "expected_code": "adoption_consumer_target_invalid",
+      "name": "malformed-local-target"
+    },
+    {
+      "expected_code": "adoption_stylegallery_revision_unpinned",
+      "name": "unpinned-stylegallery-revision"
+    },
+    {
+      "expected_code": "adoption_stylegallery_revision_unknown",
+      "name": "unknown-stylegallery-revision"
+    },
+    {
+      "expected_code": "adoption_stylegallery_path_missing",
+      "name": "missing-stylegallery-path"
+    },
+    {
+      "expected_code": "adoption_stylegallery_anchor_missing",
+      "name": "missing-stylegallery-anchor"
+    },
+    {
+      "expected_code": "adoption_debt_incomplete",
+      "name": "debt-without-lifecycle"
+    },
+    {
+      "expected_code": "consumer_source_missing",
+      "name": "missing-source"
+    },
+    {
+      "expected_code": "consumer_source_symlink",
+      "name": "symlink-source"
+    },
+    {
+      "expected_code": "runtime_command_checkout_symlink",
+      "name": "checkout-symlink"
+    },
+    {
+      "expected_code": "runtime_result_artifact_missing",
+      "name": "missing-result-artifact"
+    },
+    {
+      "expected_code": "runtime_result_artifact_symlink",
+      "name": "symlink-result-artifact"
+    },
+    {
+      "expected_code": "runtime_result_artifact_json_invalid",
+      "name": "invalid-result-artifact-json"
+    },
+    {
+      "expected_code": "runtime_result_artifact_mismatch",
+      "name": "fabricated-result-artifact"
+    },
+    {
+      "expected_code": "consumer_repository_mismatch",
+      "name": "fabricated-repository"
+    },
+    {
+      "expected_code": "consumer_revision_unknown",
+      "name": "fabricated-revision"
+    },
+    {
+      "expected_code": "runtime_source_digest_mismatch",
+      "name": "fabricated-source-digest"
+    },
+    {
+      "expected_code": "runtime_command_failed",
+      "name": "nonzero-command"
+    },
+    {
+      "expected_code": "runtime_command_result_missing",
+      "name": "forged-noop-result"
+    },
+    {
+      "expected_code": "consumer_repository_mismatch",
+      "name": "github-repository-spoof"
+    }
+  ],
+  "schema_record": "consumer-reference/schema/consumer-conformance-record.schema.json",
+  "schema_version": "1.0",
+  "valid_records": [
+    "valid-migration.json"
+  ]
+}

package/consumer-reference/fixtures/consumer-conformance/runtime-proof.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const resultReference = process.env.STYLEGALLERY_RESULT_ARTIFACT;
+const contextValue = process.env.STYLEGALLERY_RUNTIME_CONTEXT;
+assert.ok(resultReference && contextValue, "the validator must provide the result path and runtime context");
+assert.equal(path.posix.normalize(resultReference), resultReference);
+assert.ok(!path.posix.isAbsolute(resultReference) && !resultReference.split("/").includes(".."));
+
+if (process.argv.includes("--lock-worktree")) {
+  const locked = spawnSync("git", ["worktree", "lock", "."], { encoding: "utf8" });
+  assert.equal(locked.status, 0, locked.stderr);
+}
+
+const context = JSON.parse(contextValue);
+const persisted = JSON.parse(JSON.stringify({ drawer: "open", route: "/gallery", selection: null }));
+assert.deepEqual(persisted, { drawer: "open", route: "/gallery", selection: null });
+
+const output = {
+  ...context,
+  record_kind: "consumer_migration_scenario_result",
+  recorded_at: "2026-07-21T00:00:00Z",
+  schema_version: "1.0",
+  status: "passed",
+};
+const resultFile = path.resolve(process.cwd(), resultReference);
+fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+fs.writeFileSync(resultFile, `${JSON.stringify(output, null, 2)}\n`, { flag: "wx" });

package/consumer-reference/fixtures/consumer-conformance/valid-migration-result.json

@@ -0,0 +1,18 @@
+{
+  "argv": [
+    "node",
+    "consumer-reference/fixtures/consumer-conformance/runtime-proof.mjs"
+  ],
+  "evidence_method": "integration",
+  "exit_code": 0,
+  "record_kind": "consumer_migration_scenario_result",
+  "recorded_at": "2026-07-21T00:00:00Z",
+  "repository": "changeroa/StyleGallery",
+  "revision": "84bf420d568f68021117f8142e6d982b4966de2f",
+  "run_id": "run-20260721-001",
+  "scenario_id": "migration-round-trip",
+  "schema_version": "1.0",
+  "session_id": "session-20260721-001",
+  "source_digest": "6d90893774e2228ffe9ae0286f5b3392b103ea1bf5e571fcde2f7a861d76372c",
+  "status": "passed"
+}

package/consumer-reference/fixtures/consumer-conformance/valid-migration.json

@@ -0,0 +1,142 @@
+{
+  "adoption_mappings": [
+    {
+      "consumer_target": {
+        "identity": "GalleryShell",
+        "kind": "component"
+      },
+      "debt": [],
+      "deviations": [],
+      "local_decision": {
+        "decision": "Keep the spacing value consumer-local and map only the layout unit role.",
+        "identity": "--space-shell-gap",
+        "kind": "token"
+      },
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "stylegallery": {
+        "anchor": "#recommended-pattern-stack",
+        "path": "recipes/dashboard.md",
+        "revision": "66601da6e81c69674edf5c1b9b1b0862d4597fe9"
+      }
+    }
+  ],
+  "claim_boundary": {
+    "certifies_accessibility": false,
+    "certifies_product_correctness": false,
+    "scope": "This record binds migration scenarios to consumer-owned runtime evidence only."
+  },
+  "consumer": {
+    "relevant_sources": [
+      "consumer-reference/fixtures/consumer-conformance/runtime-proof.mjs",
+      "consumer-reference/schema/consumer-conformance-record.schema.json",
+      "scripts/consumer-conformance-contract.mjs",
+      "scripts/validate-consumer-conformance.mjs"
+    ],
+    "repository": "changeroa/StyleGallery",
+    "revision": "84bf420d568f68021117f8142e6d982b4966de2f"
+  },
+  "id": "example-consumer-migration",
+  "migration_dimensions": {
+    "action_parity": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "atomic_batch_behavior": {
+      "reason": "The migrated surface exposes no batch operation in this scope.",
+      "status": "not_applicable"
+    },
+    "behavior_inventory": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "contract_precedence": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "defaults_tri_state_mapping": {
+      "reason": "The migrated fields do not have defaults or tri-state semantics.",
+      "status": "not_applicable"
+    },
+    "direct_mutation": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "exact_time_boundary": {
+      "reason": "The migrated behavior has no exact-time scheduling boundary.",
+      "status": "not_applicable"
+    },
+    "field_parity": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "indirect_mutation": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "persistence_round_trip": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "reset_boundary": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "route_parity": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    },
+    "state_transitions": {
+      "scenario_ids": [
+        "migration-round-trip"
+      ],
+      "status": "applicable"
+    }
+  },
+  "page_evidence": {
+    "reason": "Page evidence is supplied by the consumer during end-to-end composition.",
+    "status": "not_applicable"
+  },
+  "record_kind": "consumer_migration_conformance",
+  "scenarios": [
+    {
+      "assertions": [
+        "The drawer state and persisted route data match after a reload."
+      ],
+      "argv": [
+        "node",
+        "consumer-reference/fixtures/consumer-conformance/runtime-proof.mjs"
+      ],
+      "evidence_method": "integration",
+      "exit_code": 0,
+      "id": "migration-round-trip",
+      "observable_actions": [
+        "Run the synthetic migration fixture and inspect its machine-readable result."
+      ],
+      "result_artifact": "consumer-reference/fixtures/consumer-conformance/valid-migration-result.json",
+      "run_id": "run-20260721-001",
+      "session_id": "session-20260721-001",
+      "source_digest": "6d90893774e2228ffe9ae0286f5b3392b103ea1bf5e571fcde2f7a861d76372c"
+    }
+  ],
+  "schema_version": "1.0"
+}

package/consumer-reference/fixtures/invalid-stable-ended-support.json

@@ -0,0 +1,19 @@
+{
+  "artifact_mode": "schema_only",
+  "fixture_independence": "related",
+  "handoff": {
+    "record": "consumer-reference/fixtures/invalid-stable-ended-support.json",
+    "status": "declared"
+  },
+  "id": "invalid-stable-ended-support",
+  "maturity": "stable",
+  "owner": {
+    "enforcement": "placeholder",
+    "name": "Repository governance owner"
+  },
+  "review_independence": "single_account",
+  "schema_version": "1.0",
+  "support": {
+    "status": "ended"
+  }
+}

package/consumer-reference/fixtures/promotion/invalid-blocking-evidence.json

@@ -0,0 +1,26 @@
+{
+  "attestations": [],
+  "compatibility": { "breaking": false, "surface": "Synthetic invariant contract surface." },
+  "decision": "deferred",
+  "deprecation": { "plan": "No deprecation while deferred.", "required": false },
+  "eligibility_basis": "full_contract",
+  "evidence": [
+    { "id": "blocking", "kind": "blocking", "reference": "synthetic-fixture:blocking", "status": "failed" },
+    { "id": "regression", "kind": "regression", "reference": "synthetic-fixture:regression", "status": "passed" }
+  ],
+  "example_only": true,
+  "exceptions": [],
+  "id": "invalid-blocking-evidence",
+  "known_issues": ["The blocking evidence failed."],
+  "migration": { "plan": "No migration while deferred.", "required": false },
+  "normative_bypass": "none",
+  "owner": { "enforcement": "placeholder", "migration": "Synthetic migration owner", "rollback": "Synthetic rollback owner", "scope": "Repository governance owner", "support": "Synthetic support owner" },
+  "provenance": { "debt_resolved": false, "source": "Synthetic fixture only" },
+  "review_independence": "single_account",
+  "rollback": { "action": "Keep deferred.", "triggers": ["Blocking evidence fails."] },
+  "schema_version": "1.0",
+  "scope": { "aesthetic": false, "kind": "invariant", "summary": "Incorrectly proceed while blocking evidence is failed." },
+  "stable_scope_decision": false,
+  "support": { "capacity": "committed", "status": "active" },
+  "transition": { "from": "consumer_local", "to": "shared_experimental" }
+}

package/consumer-reference/fixtures/promotion/invalid-count-only.json

@@ -0,0 +1,29 @@
+{
+  "attestations": [
+    { "attested_by": "Synthetic owner A", "context_id": "context-a", "consumer_id": "consumer-a", "count_toward_gate": true, "organization_id": "organization-a", "relationship": "independent" },
+    { "attested_by": "Synthetic owner B", "context_id": "context-b", "consumer_id": "consumer-b", "count_toward_gate": true, "organization_id": "organization-b", "relationship": "independent" }
+  ],
+  "compatibility": { "breaking": false, "surface": "Synthetic invariant contract surface." },
+  "decision": "deferred",
+  "deprecation": { "plan": "No deprecation while deferred.", "required": false },
+  "eligibility_basis": "consumer_count_only",
+  "evidence": [
+    { "id": "claim", "kind": "claim_scoped", "reference": "synthetic-fixture:claim", "status": "passed" },
+    { "id": "regression", "kind": "regression", "reference": "synthetic-fixture:regression", "status": "passed" }
+  ],
+  "example_only": true,
+  "exceptions": [],
+  "id": "invalid-count-only",
+  "known_issues": [],
+  "migration": { "plan": "No migration while deferred.", "required": false },
+  "normative_bypass": "none",
+  "owner": { "enforcement": "placeholder", "migration": "Synthetic migration owner", "rollback": "Synthetic rollback owner", "scope": "Repository governance owner", "support": "Synthetic support owner" },
+  "provenance": { "debt_resolved": false, "source": "Synthetic fixture only" },
+  "review_independence": "single_account",
+  "rollback": { "action": "Keep deferred.", "triggers": ["Operational duties are incomplete."] },
+  "schema_version": "1.0",
+  "scope": { "aesthetic": false, "kind": "invariant", "summary": "Incorrectly use adoption count as the whole promotion decision." },
+  "stable_scope_decision": false,
+  "support": { "capacity": "committed", "status": "active" },
+  "transition": { "from": "consumer_local", "to": "shared_experimental" }
+}