@kungfu-tech/buildchain 4.0.2 → 4.0.3-alpha.0

package/scripts/{v3-v4-capability-catalog.mjs → capability-parity-catalog.mjs}

@@ -23,8 +23,8 @@ const PLATFORM_MARKERS = Object.freeze({
   "self-hosted": /\bself-hosted\b/iu,
   windows: /\bwindows\b/iu,
 });
-const LIVE_V4_PROTECTED_BRANCH = "refs/heads/dev/v4/v4.0";
-const LIVE_V4_PROTECTED_LINEAGE_REF = "refs/remotes/origin/dev/v4/v4.0";
+const LIVE_PROTECTED_BRANCH = "refs/heads/dev/v4/v4.0";
+const LIVE_PROTECTED_LINEAGE_REF = "refs/remotes/origin/dev/v4/v4.0";
 const PROTECTED_LINEAGE_DEPTH = 256;
 
 export function sha256(value) {
@@ -85,7 +85,7 @@ export function ensureCapabilityCutAncestor({
   try {
     execFileSync(
       "git",
-      ["fetch", "--no-tags", "--depth=128", "origin", descendantCommit],
+      ["fetch", "--no-tags", "--depth=256", "origin", descendantCommit],
       { cwd: root, stdio: "ignore" },
     );
   } catch {
@@ -96,7 +96,7 @@ export function ensureCapabilityCutAncestor({
   assertCapabilityCutAncestor({ root, revision, descendant, label });
 }
 
-function protectedV4TreeWitness(root, descendant) {
+function protectedTreeWitness(root, descendant) {
   try {
     execFileSync(
       "git",
@@ -105,13 +105,13 @@ function protectedV4TreeWitness(root, descendant) {
         "--no-tags",
         `--depth=${PROTECTED_LINEAGE_DEPTH}`,
         "origin",
-        `${LIVE_V4_PROTECTED_BRANCH}:${LIVE_V4_PROTECTED_LINEAGE_REF}`,
+        `${LIVE_PROTECTED_BRANCH}:${LIVE_PROTECTED_LINEAGE_REF}`,
       ],
       { cwd: root, stdio: "ignore" },
     );
   } catch {
     throw new Error(
-      `protected v4 lineage ${LIVE_V4_PROTECTED_BRANCH} could not be hydrated through a bounded origin fetch`,
+      `protected v4 lineage ${LIVE_PROTECTED_BRANCH} could not be hydrated through a bounded origin fetch`,
     );
   }
   const tree = git(root, ["rev-parse", `${descendant}^{tree}`]);
@@ -120,7 +120,7 @@ function protectedV4TreeWitness(root, descendant) {
       "log",
       `--max-count=${PROTECTED_LINEAGE_DEPTH}`,
       "--format=%H %T",
-      LIVE_V4_PROTECTED_LINEAGE_REF,
+      LIVE_PROTECTED_LINEAGE_REF,
     ])
       .split("\n")
       .map((row) => row.split(" "))
@@ -138,7 +138,7 @@ export function ensureCapabilityCutLineage({
     ensureCapabilityCutAncestor({ root, revision, descendant, label });
     return { mode: "direct-ancestry", witness: descendant };
   } catch (directError) {
-    const witness = protectedV4TreeWitness(root, descendant);
+    const witness = protectedTreeWitness(root, descendant);
     if (!witness)
       throw new Error(
         `${label} ${revision} is not an ancestor of ${descendant}, and ${descendant} has no tree-equivalent commit in the bounded protected v4 lineage`,
@@ -394,12 +394,12 @@ function addMechanismCatalog(
   catalog,
   mechanismInventory,
   runtimeSemanticClosure,
-  isLiveV3,
+  isLiveBaseline,
 ) {
-  const mechanisms = isLiveV3
+  const mechanisms = isLiveBaseline
     ? mechanismInventory.mechanisms || []
     : runtimeSemanticClosure.capabilities || [];
-  const relPath = isLiveV3
+  const relPath = isLiveBaseline
     ? "architecture/v3-core-mechanism-inventory.json"
     : "architecture/v4-runtime-semantic-closure.json";
   for (const mechanism of mechanisms) {
@@ -439,7 +439,7 @@ function addPlatformCatalog(catalog, root, revision, paths) {
   }
 }
 
-export function collectRevisionCatalog({ root, revision, liveV3Revision }) {
+export function collectRevisionCatalog({ root, revision, liveV3Revision: liveBaselineRevision }) {
   const catalog = new Map();
   const paths = gitPaths(root, revision);
   const pathSet = new Set(paths);
@@ -461,7 +461,7 @@ export function collectRevisionCatalog({ root, revision, liveV3Revision }) {
     "architecture/v3-core-mechanism-inventory.json",
   );
   const runtimeSemanticClosure =
-    revision === liveV3Revision
+    revision === liveBaselineRevision
       ? null
       : gitJson(
           root,
@@ -476,7 +476,7 @@ export function collectRevisionCatalog({ root, revision, liveV3Revision }) {
     catalog,
     mechanismInventory,
     runtimeSemanticClosure,
-    revision === liveV3Revision,
+    revision === liveBaselineRevision,
   );
   addPlatformCatalog(catalog, root, revision, paths);
   return { catalog, paths: pathSet };
@@ -485,8 +485,8 @@ export function collectRevisionCatalog({ root, revision, liveV3Revision }) {
 export function collectHistoryRows({
   root,
   priorRevision,
-  liveV3Revision,
-  v4Paths,
+  liveV3Revision: liveBaselineRevision,
+  v4Paths: domainPaths,
   migrationPaths,
   ownerAssignment,
 }) {
@@ -494,7 +494,7 @@ export function collectHistoryRows({
     "diff",
     "--name-status",
     priorRevision,
-    liveV3Revision,
+    liveBaselineRevision,
   ]);
   return output
     .split("\n")
@@ -503,11 +503,11 @@ export function collectHistoryRows({
       const fields = line.split("\t");
       const sourcePath = fields.at(-1);
       const migrationPath = migrationPaths.get(sourcePath);
-      if (!v4Paths.has(sourcePath) && !migrationPath)
+      if (!domainPaths.has(sourcePath) && !migrationPath)
         throw new Error(
           `unclassified post-family v3 history path: ${sourcePath}`,
         );
-      if (migrationPath && !v4Paths.has(migrationPath))
+      if (migrationPath && !domainPaths.has(migrationPath))
         throw new Error(
           `history migration route is absent from the exact v4 cut: ${migrationPath}`,
         );

package/scripts/check-action-bundles.mjs

@@ -20,9 +20,9 @@ const javascriptBundlePaths = readdirSync(actionsRoot, { withFileTypes: true })
 const wasmBundlePaths = [
   "promote-buildchain-ref",
   "release-tail",
-  "v4-release-candidate-promote",
+  "release-candidate-promote",
 ].map((name) =>
-  path.join(actionsRoot, name, "dist", "buildchain-v4-domain.wasm"),
+  path.join(actionsRoot, name, "dist", "buildchain-domain.wasm"),
 );
 const bundlePaths = [...javascriptBundlePaths, ...wasmBundlePaths];
 

package/scripts/{check-v3-v4-capability-inventory.mjs → check-capability-parity-inventory.mjs}

@@ -11,16 +11,16 @@ import {
   ensureCapabilityCutLineage,
   git,
   sha256,
-} from "./v3-v4-capability-catalog.mjs";
+} from "./capability-parity-catalog.mjs";
 
-export const V3_V4_CAPABILITY_INVENTORY_CONTRACT =
+export const BASELINE_CAPABILITY_INVENTORY_CONTRACT =
   "kungfu-buildchain-v3-v4-live-capability-inventory";
-export const V3_V4_CAPABILITY_CUTS = Object.freeze({
+export const BASELINE_CAPABILITY_CUTS = Object.freeze({
   priorFamilyV3: "6b96bdad8d9f8ccf9275f27d9370a226a9c78465",
   liveV3: "8493bf140a7f567e76aff3119f3d39ff026afc84",
   liveV4: "97edd5b93eb67e5bf36ad55726e08231b47b70c0",
 });
-const INVENTORY_PATH = "architecture/v3-v4-live-capability-inventory.json";
+const INVENTORY_PATH = "architecture/capability-parity-live-capability-inventory.json";
 const ALLOWED_DISPOSITIONS = new Set([
   "v4-native",
   "compatibility-adapter",
@@ -30,7 +30,7 @@ const ALLOWED_DISPOSITIONS = new Set([
 const ASSIGNMENTS = Object.freeze({
   public: "2026-08-26-buildchain-v4-public-surface-compatibility-closure",
   runtime: "2026-08-26-buildchain-v4-runtime-semantic-closure",
-  adopter: "2026-08-26-buildchain-v4-cross-platform-adopter-qualification",
+  adopter: "2026-08-26-buildchain-cross-platform-adopter-qualification",
   stable: "2026-08-26-buildchain-v4-stable-channel-capability-closure",
   retirement: "2026-08-26-buildchain-v4-v3-retirement-reconciliation",
 });
@@ -93,7 +93,7 @@ function capabilityCutAvailable(root, revision) {
 }
 
 function ensureCapabilityCutsAvailable(root) {
-  const revisions = Object.values(V3_V4_CAPABILITY_CUTS);
+  const revisions = Object.values(BASELINE_CAPABILITY_CUTS);
   const missing = revisions.filter(
     (revision) => !capabilityCutAvailable(root, revision),
   );
@@ -114,7 +114,7 @@ function ensureCapabilityCutsAvailable(root) {
   }
   ensureCapabilityCutLineage({
     root,
-    revision: V3_V4_CAPABILITY_CUTS.liveV4,
+    revision: BASELINE_CAPABILITY_CUTS.liveV4,
     label: "live v4 capability cut",
   });
 }
@@ -233,14 +233,14 @@ function rowFromCatalogEntry(source, targetCatalog) {
   const migratedId = MIGRATION_ROUTES.get(source.id);
   const migrated = migratedId ? targetCatalog.get(migratedId) : undefined;
   let disposition;
-  let v4Route = null;
+  let route = null;
   let residual = null;
   if (direct) {
     disposition = "v4-native";
-    v4Route = { capabilityId: direct.id, evidence: direct.evidence };
+    route = { capabilityId: direct.id, evidence: direct.evidence };
   } else if (migrated) {
     disposition = "executable-migration";
-    v4Route = { capabilityId: migrated.id, evidence: migrated.evidence };
+    route = { capabilityId: migrated.id, evidence: migrated.evidence };
   } else if (PUBLIC_SURFACE_CLOSURE_IDS.has(source.id)) {
     disposition = "owned-missing";
     residual = {
@@ -257,7 +257,7 @@ function rowFromCatalogEntry(source, targetCatalog) {
     disposition,
     ownerAssignment,
     sourceEvidence: source.evidence,
-    v4Route,
+    v4Route: route,
     residual,
     positiveProbe:
       disposition === "owned-missing"
@@ -279,33 +279,33 @@ function sourceCut(root, commit, role) {
   };
 }
 
-export function buildV3V4CapabilityInventory({ root = process.cwd() } = {}) {
+export function buildBaselineCapabilityInventory({ root = process.cwd() } = {}) {
   ensureCapabilityCutsAvailable(root);
   git(root, [
     "merge-base",
     "--is-ancestor",
-    V3_V4_CAPABILITY_CUTS.priorFamilyV3,
-    V3_V4_CAPABILITY_CUTS.liveV3,
+    BASELINE_CAPABILITY_CUTS.priorFamilyV3,
+    BASELINE_CAPABILITY_CUTS.liveV3,
   ]);
-  const v3 = collectRevisionCatalog({
+  const baseline = collectRevisionCatalog({
     root,
-    revision: V3_V4_CAPABILITY_CUTS.liveV3,
-    liveV3Revision: V3_V4_CAPABILITY_CUTS.liveV3,
+    revision: BASELINE_CAPABILITY_CUTS.liveV3,
+    liveV3Revision: BASELINE_CAPABILITY_CUTS.liveV3,
   });
-  const v4 = collectRevisionCatalog({
+  const domain = collectRevisionCatalog({
     root,
-    revision: V3_V4_CAPABILITY_CUTS.liveV4,
-    liveV3Revision: V3_V4_CAPABILITY_CUTS.liveV3,
+    revision: BASELINE_CAPABILITY_CUTS.liveV4,
+    liveV3Revision: BASELINE_CAPABILITY_CUTS.liveV3,
   });
   const rows = [
-    ...[...v3.catalog.values()].map((entry) =>
-      rowFromCatalogEntry(entry, v4.catalog),
+    ...[...baseline.catalog.values()].map((entry) =>
+      rowFromCatalogEntry(entry, domain.catalog),
     ),
     ...collectHistoryRows({
       root,
-      priorRevision: V3_V4_CAPABILITY_CUTS.priorFamilyV3,
-      liveV3Revision: V3_V4_CAPABILITY_CUTS.liveV3,
-      v4Paths: v4.paths,
+      priorRevision: BASELINE_CAPABILITY_CUTS.priorFamilyV3,
+      liveV3Revision: BASELINE_CAPABILITY_CUTS.liveV3,
+      v4Paths: domain.paths,
       migrationPaths: HISTORY_MIGRATION_PATHS,
       ownerAssignment: ASSIGNMENTS.retirement,
     }),
@@ -313,24 +313,24 @@ export function buildV3V4CapabilityInventory({ root = process.cwd() } = {}) {
   const changedPaths = rows.filter((row) => row.category === "history-change");
   const prior = sourceCut(
     root,
-    V3_V4_CAPABILITY_CUTS.priorFamilyV3,
+    BASELINE_CAPABILITY_CUTS.priorFamilyV3,
     "previous-absorption-family-capture",
   );
-  const liveV3 = sourceCut(
+  const baselineCut = sourceCut(
     root,
-    V3_V4_CAPABILITY_CUTS.liveV3,
+    BASELINE_CAPABILITY_CUTS.liveV3,
     "execution-time-protected-read-only-reference",
   );
-  const liveV4 = sourceCut(
+  const currentCut = sourceCut(
     root,
-    V3_V4_CAPABILITY_CUTS.liveV4,
+    BASELINE_CAPABILITY_CUTS.liveV4,
     "execution-time-protected-target",
   );
-  liveV4.branch = "origin/dev/v4/v4.0";
+  currentCut.branch = "origin/dev/v4/v4.0";
   const inventory = {
     schemaVersion: 1,
-    contract: V3_V4_CAPABILITY_INVENTORY_CONTRACT,
-    sourceCuts: { priorFamilyV3: prior, liveV3, liveV4 },
+    contract: BASELINE_CAPABILITY_INVENTORY_CONTRACT,
+    sourceCuts: { priorFamilyV3: prior, liveV3: baselineCut, liveV4: currentCut },
     extraction: {
       mode: "exact-git-object-closed-world",
       extractor: "scripts/check-v3-v4-capability-inventory.mjs",
@@ -352,13 +352,13 @@ export function buildV3V4CapabilityInventory({ root = process.cwd() } = {}) {
       residualPolicy: "exact-identity-allowlist-with-required-owner",
     },
     reverseHistory: {
-      fromCommit: V3_V4_CAPABILITY_CUTS.priorFamilyV3,
-      toCommit: V3_V4_CAPABILITY_CUTS.liveV3,
+      fromCommit: BASELINE_CAPABILITY_CUTS.priorFamilyV3,
+      toCommit: BASELINE_CAPABILITY_CUTS.liveV3,
       commitCount: Number(
         git(root, [
           "rev-list",
           "--count",
-          `${V3_V4_CAPABILITY_CUTS.priorFamilyV3}..${V3_V4_CAPABILITY_CUTS.liveV3}`,
+          `${BASELINE_CAPABILITY_CUTS.priorFamilyV3}..${BASELINE_CAPABILITY_CUTS.liveV3}`,
         ]),
       ),
       changedPathCount: changedPaths.length,
@@ -378,7 +378,7 @@ export function buildV3V4CapabilityInventory({ root = process.cwd() } = {}) {
     },
     capabilities: rows,
   };
-  assertV3V4CapabilityInventory(inventory);
+  assertBaselineCapabilityInventory(inventory);
   return inventory;
 }
 
@@ -448,8 +448,8 @@ function validateCoverage(inventory, rows, issues) {
   }
   if (
     inventory?.reverseHistory?.fromCommit !==
-      V3_V4_CAPABILITY_CUTS.priorFamilyV3 ||
-    inventory?.reverseHistory?.toCommit !== V3_V4_CAPABILITY_CUTS.liveV3 ||
+      BASELINE_CAPABILITY_CUTS.priorFamilyV3 ||
+    inventory?.reverseHistory?.toCommit !== BASELINE_CAPABILITY_CUTS.liveV3 ||
     inventory?.reverseHistory?.unclassifiedPathCount !== 0
   ) {
     issues.push(
@@ -464,11 +464,11 @@ function validateCoverage(inventory, rows, issues) {
   }
 }
 
-export function assertV3V4CapabilityInventory(inventory) {
+export function assertBaselineCapabilityInventory(inventory) {
   const issues = [];
   if (
     inventory?.schemaVersion !== 1 ||
-    inventory?.contract !== V3_V4_CAPABILITY_INVENTORY_CONTRACT
+    inventory?.contract !== BASELINE_CAPABILITY_INVENTORY_CONTRACT
   ) {
     issues.push("inventory contract or schemaVersion is invalid");
   }
@@ -487,7 +487,7 @@ export function assertV3V4CapabilityInventory(inventory) {
 
 function main() {
   const root = process.cwd();
-  const inventory = buildV3V4CapabilityInventory({ root });
+  const inventory = buildBaselineCapabilityInventory({ root });
   const expected = canonicalInventoryJson(inventory);
   if (process.argv.includes("--write")) {
     fs.writeFileSync(path.join(root, INVENTORY_PATH), expected);

package/scripts/check-core-mechanism-inventory.mjs

@@ -275,7 +275,10 @@ function validateReverseScan(root, inventory, ids, ownedSources, issues) {
 
 function checkCoreMechanismInventory({
   root = process.cwd(),
-  inventory = loadJson(root, "architecture/v3-core-mechanism-inventory.json"),
+  inventory = loadJson(
+    root,
+    "architecture/baseline-core-mechanism-inventory.json",
+  ),
 } = {}) {
   const issues = [];
   if (

package/scripts/{check-v4-floating-consumer-policy-contract.mjs → check-floating-consumer-policy-contract.mjs}

@@ -83,14 +83,14 @@ function assertPersistedSelectors() {
           ".github/workflows/self-ops-promotion-recovery.yml" &&
         match[1] === ".github/workflows/.release-candidate-promote.yml" &&
         selector === "alpha/v4/v4.0";
-      const isV4 =
+      const isCurrentMajor =
         selector === "v4" ||
         selector === "v4-alpha" ||
         /^v4(?:[./-]|$)/u.test(selector) ||
         /^[0-9a-f]{40}$/iu.test(selector) ||
         selector.includes("${{");
       if (
-        (isV4 || protectedBootstrap) &&
+        (isCurrentMajor || protectedBootstrap) &&
         !["v4", "v4-alpha"].includes(selector) &&
         !protectedBootstrap
       ) {
@@ -104,9 +104,9 @@ function assertPersistedSelectors() {
     );
 }
 
-export function checkV4FloatingConsumerPolicyContract() {
+export function checkFloatingConsumerPolicyContract() {
   const policy = JSON.parse(
-    read("architecture/v4-floating-consumer-policy.json"),
+    read("architecture/floating-consumer-policy.json"),
   );
   if (policy.contract !== "kungfu-buildchain-v4-floating-consumer-policy/v1") {
     fail("architecture policy contract is missing");
@@ -173,12 +173,12 @@ export function checkV4FloatingConsumerPolicyContract() {
     ["packages/core/release-candidate.js", "consumerPolicy"],
     ["packages/core/release-passport.js", "v4ConsumerPolicy"],
     [
-      "actions/v4-release-candidate-promote/index.js",
+      "actions/release-candidate-promote/index.js",
       "candidate.consumerPolicy?.receiptRoot",
     ],
     [
-      "actions/v4-release-candidate-promote/index.js",
-      "createV4ReleaseInvocation",
+      "actions/release-candidate-promote/index.js",
+      "createReleaseInvocation",
     ],
   ]) {
     if (!read(relative).includes(marker)) {
@@ -205,7 +205,7 @@ if (
 ) {
   try {
     process.stdout.write(
-      `${JSON.stringify(checkV4FloatingConsumerPolicyContract(), null, 2)}\n`,
+      `${JSON.stringify(checkFloatingConsumerPolicyContract(), null, 2)}\n`,
     );
   } catch (error) {
     console.error(error.message);

package/scripts/check-implementation-naming.mjs

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+
+const ROOTS = new Set([
+  "actions",
+  "bin",
+  "crates",
+  "packages",
+  "scripts",
+  "tests",
+]);
+const GENERATION_PATH = /(?:^|[-_])v\d+(?:[-_]|$)/iu;
+const PROTOCOL_VERSION_SYMBOLS = new Set([
+  "createSourceQualificationProofV2",
+  "loadedV2",
+]);
+const GENERATION_SYMBOL =
+  /(?:^|_)V\d+(?:_|$)|V\d+(?=[A-Z]|$)|^v\d+(?=[A-Z]|$)/u;
+
+export function inspectImplementationName(file, source) {
+  const issues = [];
+  if (!ROOTS.has(file.split("/")[0])) return issues;
+  for (const component of file.split("/")) {
+    if (GENERATION_PATH.test(component))
+      issues.push(`${file}: implementation path contains a product generation`);
+  }
+  if (file.endsWith(".rs")) {
+    for (const match of source.matchAll(
+      /\b(?:fn|struct|enum|mod|const|let)\s+([A-Za-z_][A-Za-z0-9_]*)/gu,
+    ))
+      if (
+        GENERATION_SYMBOL.test(match[1]) ||
+        /(?:^|_)v\d+(?:_|$)/u.test(match[1])
+      )
+        issues.push(`${file}: ${match[1]} must describe its responsibility`);
+  }
+  if (!/\.(?:[cm]?js|ts)$/u.test(file) || file.includes("/dist/"))
+    return issues;
+  const syntax = ts.createSourceFile(
+    file,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  const visit = (node) => {
+    if (
+      (ts.isFunctionDeclaration(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isVariableDeclaration(node) ||
+        ts.isParameter(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isBindingElement(node)) &&
+      node.name &&
+      ts.isIdentifier(node.name) &&
+      GENERATION_SYMBOL.test(node.name.text) &&
+      !PROTOCOL_VERSION_SYMBOLS.has(node.name.text) &&
+      !/_V\d+_SCHEMA$/u.test(node.name.text)
+    ) {
+      const line =
+        syntax.getLineAndCharacterOfPosition(node.name.getStart()).line + 1;
+      issues.push(
+        `${file}:${line}: ${node.name.text} must describe its responsibility`,
+      );
+    }
+    if (
+      (ts.isStringLiteral(node) ||
+        ts.isNoSubstitutionTemplateLiteral(node) ||
+        ts.isTemplateHead(node) ||
+        ts.isTemplateMiddle(node) ||
+        ts.isTemplateTail(node)) &&
+      /\.buildchain\/[A-Za-z0-9_./-]*\bv\d+-/u.test(node.text)
+    )
+      issues.push(
+        `${file}: runtime directory must describe its responsibility`,
+      );
+    ts.forEachChild(node, visit);
+  };
+  visit(syntax);
+  return issues;
+}
+
+export function checkImplementationNaming(root = process.cwd()) {
+  const files = execFileSync("git", ["ls-files", "-z"], {
+    cwd: root,
+    encoding: "utf8",
+  })
+    .split("\0")
+    .filter(Boolean);
+  const issues = files.flatMap((file) => {
+    const absolute = path.join(root, file);
+    if (!fs.existsSync(absolute))
+      return [`${file}: tracked implementation is missing`];
+    const source =
+      ROOTS.has(file.split("/")[0]) && /\.(?:[cm]?js|ts|rs)$/u.test(file)
+        ? fs.readFileSync(absolute, "utf8")
+        : "";
+    return inspectImplementationName(file, source);
+  });
+  const manifest = JSON.parse(
+    fs.readFileSync(path.join(root, "package.json"), "utf8"),
+  );
+  for (const name of Object.keys(manifest.scripts || {})) {
+    if (/(?:^|:)v\d+(?:[-:]|$)/iu.test(name))
+      issues.push(`package.json: script ${name} contains a product generation`);
+  }
+  const policy = JSON.parse(
+    fs.readFileSync(
+      path.join(root, "architecture/implementation-naming.json"),
+      "utf8",
+    ),
+  );
+  for (const [file, identities] of Object.entries(policy.wireIdentities)) {
+    const source = fs.readFileSync(path.join(root, file), "utf8");
+    for (const previousIdentity of identities) {
+      const identity =
+        policy.implementationIdentityMigrations?.[file]?.[previousIdentity] ||
+        previousIdentity;
+      if (
+        !source.includes(JSON.stringify(identity)) &&
+        !source.includes(`'${identity}'`)
+      )
+        issues.push(
+          `${file}: published wire identity changed during implementation relocation: ${identity}`,
+        );
+    }
+  }
+  if (issues.length) throw new Error(issues.join("\n"));
+  return { checkedFiles: files.length, issues: [] };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
+  console.log(JSON.stringify(checkImplementationNaming(), null, 2));

package/scripts/check-inventory.mjs

@@ -207,7 +207,7 @@ const currentBuildchainContract = JSON.parse(
   fs.readFileSync(path.join(root, "dist/site/buildchain-contract.json"), "utf8"),
 );
 const selfDogfoodBootstrapAuthority = JSON.parse(
-  fs.readFileSync(path.join(root, "architecture/v4-bootstrap-authority.json"), "utf8"),
+  fs.readFileSync(path.join(root, "architecture/bootstrap-authority.json"), "utf8"),
 );
 const selfDogfoodMajorResolution = resolveSelfDogfoodMajor({
   packageVersion: rootPackage.version,
@@ -546,7 +546,8 @@ if (!coreIndexSource.includes("KFD2_RELEASE_TRUST_PASSPORT_CONTRACT")) {
 if (!coreIndexSource.includes("KFD2_TRUST_PROOF_CONTRACT")) {
   throw new Error("packages/core/index.js must export KFD-2 trust proof contract");
 }
-if (!coreIndexSource.includes("createSurfaceTimestampPolicy")) {
+const publicCore = await import("../packages/core/index.js");
+if (typeof publicCore.createSurfaceTimestampPolicy !== "function") {
   throw new Error("packages/core/index.js must export surface manifest timestamp policy APIs");
 }
 for (const requiredSnippet of [
@@ -1044,7 +1045,7 @@ for (const requiredSnippet of [
   "uses: kungfu-systems/buildchain/.github/workflows/.release-candidate-promote.yml@v4-alpha",
   "github.event.workflow_run.event == 'push'",
   "name: Classify generated product-state finalization",
-  "selectV4FinalizedProductPublicationVersion",
+  "selectFinalizedProductPublicationVersion",
   "resume-candidate-run-id:",
   "resume-expected-source-tree:",
   "resume-buildchain-runtime-ref:",
@@ -1066,9 +1067,9 @@ for (const requiredSnippet of [
   "name: QUALIFY canonical v4 release invocation inputs",
   "name: APPLY one rooted provider transaction",
   "name: SETTLE terminal ReleaseReceipt projection",
-  "uses: ./.buildchain/runtime/actions/v4-release-candidate-promote",
+  "uses: ./.buildchain/runtime/actions/release-candidate-promote",
   "name: Resolve one exact product publication recovery",
-  "selectV4RecoveredProductPublicationVersion",
+  "selectRecoveredProductPublicationVersion",
   "publisher-workflow-sha:",
   "runtime-commit:",
   "runtime-tree:",

package/scripts/check-maintainability.mjs

@@ -112,6 +112,13 @@ function ensureMaintainabilityRevisionsAvailable(
   );
 }
 
+function implementationPathAtPresent(root, historicalPath) {
+  const policyPath = path.join(root, "architecture/implementation-naming.json");
+  if (!fs.existsSync(policyPath)) return historicalPath;
+  const policy = readJson(root, "architecture/implementation-naming.json");
+  return policy.pathMigrations[historicalPath] || historicalPath;
+}
+
 function sourceMetricsAtRevision(root, revision) {
   const files = gitOutput(root, ["ls-tree", "-r", "--name-only", revision])
     .split("\n")
@@ -119,7 +126,7 @@ function sourceMetricsAtRevision(root, revision) {
     .sort();
   return Object.fromEntries(
     files.map((file) => [
-      file,
+      implementationPathAtPresent(root, file),
       analyzeSource(file, gitOutput(root, ["show", `${revision}:${file}`])),
     ]),
   );
@@ -134,7 +141,7 @@ function testMetricsAtRevision(root, revision) {
     .sort();
   return Object.fromEntries(
     files.map((file) => [
-      file,
+      implementationPathAtPresent(root, file),
       analyzeSource(file, gitOutput(root, ["show", `${revision}:${file}`])),
     ]),
   );