@oddessentials/repo-standards 4.2.0 → 4.3.0

package/dist/index.cjs

@@ -41,7 +41,7 @@ var import_node_fs = require("fs");
 var import_node_path = require("path");
 
 // src/version.ts
-var STANDARDS_VERSION = "4.1.0";
+var STANDARDS_VERSION = "4.2.0";
 var STANDARDS_SCHEMA_VERSION = 4;
 
 // src/index.ts

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../node_modules/tsup/assets/cjs_shims.js","../src/version.ts"],"sourcesContent":["import { fileURLToPath } from \"node:url\";\nimport { readFileSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport type {\n  MasterJson,\n  StackChecklistJson,\n  StackId,\n  CiSystem,\n} from \"./types.js\";\nimport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION } from \"./version.js\";\n\n// Re-export types for consumers\nexport type { MasterJson, StackChecklistJson, StackId, CiSystem };\n\n// Re-export version info (stable API contract)\nexport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION };\n\n// ESM equivalent of __dirname\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n// Path to config directory:\n// - When running from src/ (dev/test): use repo root config/\n// - When running from dist/ (installed): use dist/config/\nconst isDevMode = __dirname.includes(\"src\");\nconst configDir = isDevMode\n  ? join(__dirname, \"..\", \"config\")\n  : join(__dirname, \"config\");\n\n/** Load the master spec JSON from the packaged dist directory */\nexport function loadMasterSpec(): MasterJson {\n  const filePath = join(configDir, \"standards.json\");\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** Load a stack-specific checklist (optionally filtered by CI system) */\nexport function loadBaseline(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  const suffix = ci ? `.${ci}` : \"\";\n  const file = `standards.${stack}${suffix}.json`;\n  const filePath = join(configDir, file);\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** List all supported stacks (derived from the master spec) */\nexport function listSupportedStacks(): readonly StackId[] {\n  const spec = loadMasterSpec();\n  return Object.keys(spec.stacks) as StackId[];\n}\n\n/** List all supported CI systems (derived from the master spec) */\nexport function listSupportedCiSystems(): readonly CiSystem[] {\n  const spec = loadMasterSpec();\n  return spec.ciSystems as CiSystem[];\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadBaseline - loads stack-specific standards checklist.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getStandards(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  return loadBaseline(stack, ci);\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadMasterSpec - loads the master standards schema.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getSchema(): MasterJson {\n  return loadMasterSpec();\n}\n","// Shim globals in cjs bundle\n// There's a weird bug that esbuild will always inject importMetaUrl\n// if we export it as `const importMetaUrl = ... __filename ...`\n// But using a function will not cause this issue\n\nconst getImportMetaUrl = () => \n  typeof document === \"undefined\" \n    ? new URL(`file:${__filename}`).href \n    : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT') \n      ? document.currentScript.src \n      : new URL(\"main.js\", document.baseURI).href;\n\nexport const importMetaUrl = /* @__PURE__ */ getImportMetaUrl()\n","/**\n * AUTO-GENERATED at build time by scripts/build.ts\n * DO NOT EDIT MANUALLY\n *\n * This module provides version information for the repo-standards package.\n * Consumers should import from here instead of package.json to avoid\n * ESM/CJS interop issues.\n */\n\nexport const STANDARDS_VERSION = '4.1.0';\nexport const STANDARDS_SCHEMA_VERSION = 4;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKA,IAAM,mBAAmB,MACvB,OAAO,aAAa,cAChB,IAAI,IAAI,QAAQ,UAAU,EAAE,EAAE,OAC7B,SAAS,iBAAiB,SAAS,cAAc,QAAQ,YAAY,MAAM,WAC1E,SAAS,cAAc,MACvB,IAAI,IAAI,WAAW,SAAS,OAAO,EAAE;AAEtC,IAAM,gBAAgC,iCAAiB;;;ADZ9D,sBAA8B;AAC9B,qBAA6B;AAC7B,uBAA8B;;;AEOvB,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;;;AFQxC,IAAMA,kBAAa,+BAAc,aAAe;AAChD,IAAM,gBAAY,0BAAQA,WAAU;AAKpC,IAAM,YAAY,UAAU,SAAS,KAAK;AAC1C,IAAM,YAAY,gBACd,uBAAK,WAAW,MAAM,QAAQ,QAC9B,uBAAK,WAAW,QAAQ;AAGrB,SAAS,iBAA6B;AAC3C,QAAM,eAAW,uBAAK,WAAW,gBAAgB;AACjD,SAAO,KAAK,UAAM,6BAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,aACd,OACA,IACoB;AACpB,QAAM,SAAS,KAAK,IAAI,EAAE,KAAK;AAC/B,QAAM,OAAO,aAAa,KAAK,GAAG,MAAM;AACxC,QAAM,eAAW,uBAAK,WAAW,IAAI;AACrC,SAAO,KAAK,UAAM,6BAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,sBAA0C;AACxD,QAAM,OAAO,eAAe;AAC5B,SAAO,OAAO,KAAK,KAAK,MAAM;AAChC;AAGO,SAAS,yBAA8C;AAC5D,QAAM,OAAO,eAAe;AAC5B,SAAO,KAAK;AACd;AAOO,SAAS,aACd,OACA,IACoB;AACpB,SAAO,aAAa,OAAO,EAAE;AAC/B;AAOO,SAAS,YAAwB;AACtC,SAAO,eAAe;AACxB;","names":["__filename"]}
+{"version":3,"sources":["../src/index.ts","../node_modules/tsup/assets/cjs_shims.js","../src/version.ts"],"sourcesContent":["import { fileURLToPath } from \"node:url\";\nimport { readFileSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport type {\n  MasterJson,\n  StackChecklistJson,\n  StackId,\n  CiSystem,\n} from \"./types.js\";\nimport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION } from \"./version.js\";\n\n// Re-export types for consumers\nexport type { MasterJson, StackChecklistJson, StackId, CiSystem };\n\n// Re-export version info (stable API contract)\nexport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION };\n\n// ESM equivalent of __dirname\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n// Path to config directory:\n// - When running from src/ (dev/test): use repo root config/\n// - When running from dist/ (installed): use dist/config/\nconst isDevMode = __dirname.includes(\"src\");\nconst configDir = isDevMode\n  ? join(__dirname, \"..\", \"config\")\n  : join(__dirname, \"config\");\n\n/** Load the master spec JSON from the packaged dist directory */\nexport function loadMasterSpec(): MasterJson {\n  const filePath = join(configDir, \"standards.json\");\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** Load a stack-specific checklist (optionally filtered by CI system) */\nexport function loadBaseline(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  const suffix = ci ? `.${ci}` : \"\";\n  const file = `standards.${stack}${suffix}.json`;\n  const filePath = join(configDir, file);\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** List all supported stacks (derived from the master spec) */\nexport function listSupportedStacks(): readonly StackId[] {\n  const spec = loadMasterSpec();\n  return Object.keys(spec.stacks) as StackId[];\n}\n\n/** List all supported CI systems (derived from the master spec) */\nexport function listSupportedCiSystems(): readonly CiSystem[] {\n  const spec = loadMasterSpec();\n  return spec.ciSystems as CiSystem[];\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadBaseline - loads stack-specific standards checklist.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getStandards(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  return loadBaseline(stack, ci);\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadMasterSpec - loads the master standards schema.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getSchema(): MasterJson {\n  return loadMasterSpec();\n}\n","// Shim globals in cjs bundle\n// There's a weird bug that esbuild will always inject importMetaUrl\n// if we export it as `const importMetaUrl = ... __filename ...`\n// But using a function will not cause this issue\n\nconst getImportMetaUrl = () => \n  typeof document === \"undefined\" \n    ? new URL(`file:${__filename}`).href \n    : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT') \n      ? document.currentScript.src \n      : new URL(\"main.js\", document.baseURI).href;\n\nexport const importMetaUrl = /* @__PURE__ */ getImportMetaUrl()\n","/**\n * AUTO-GENERATED at build time by scripts/build.ts\n * DO NOT EDIT MANUALLY\n *\n * This module provides version information for the repo-standards package.\n * Consumers should import from here instead of package.json to avoid\n * ESM/CJS interop issues.\n */\n\nexport const STANDARDS_VERSION = '4.2.0';\nexport const STANDARDS_SCHEMA_VERSION = 4;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKA,IAAM,mBAAmB,MACvB,OAAO,aAAa,cAChB,IAAI,IAAI,QAAQ,UAAU,EAAE,EAAE,OAC7B,SAAS,iBAAiB,SAAS,cAAc,QAAQ,YAAY,MAAM,WAC1E,SAAS,cAAc,MACvB,IAAI,IAAI,WAAW,SAAS,OAAO,EAAE;AAEtC,IAAM,gBAAgC,iCAAiB;;;ADZ9D,sBAA8B;AAC9B,qBAA6B;AAC7B,uBAA8B;;;AEOvB,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;;;AFQxC,IAAMA,kBAAa,+BAAc,aAAe;AAChD,IAAM,gBAAY,0BAAQA,WAAU;AAKpC,IAAM,YAAY,UAAU,SAAS,KAAK;AAC1C,IAAM,YAAY,gBACd,uBAAK,WAAW,MAAM,QAAQ,QAC9B,uBAAK,WAAW,QAAQ;AAGrB,SAAS,iBAA6B;AAC3C,QAAM,eAAW,uBAAK,WAAW,gBAAgB;AACjD,SAAO,KAAK,UAAM,6BAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,aACd,OACA,IACoB;AACpB,QAAM,SAAS,KAAK,IAAI,EAAE,KAAK;AAC/B,QAAM,OAAO,aAAa,KAAK,GAAG,MAAM;AACxC,QAAM,eAAW,uBAAK,WAAW,IAAI;AACrC,SAAO,KAAK,UAAM,6BAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,sBAA0C;AACxD,QAAM,OAAO,eAAe;AAC5B,SAAO,OAAO,KAAK,KAAK,MAAM;AAChC;AAGO,SAAS,yBAA8C;AAC5D,QAAM,OAAO,eAAe;AAC5B,SAAO,KAAK;AACd;AAOO,SAAS,aACd,OACA,IACoB;AACpB,SAAO,aAAa,OAAO,EAAE;AAC/B;AAOO,SAAS,YAAwB;AACtC,SAAO,eAAe;AACxB;","names":["__filename"]}

package/dist/index.d.cts

@@ -156,7 +156,7 @@ interface StackChecklistJson {
  * Consumers should import from here instead of package.json to avoid
  * ESM/CJS interop issues.
  */
-declare const STANDARDS_VERSION = "4.1.0";
+declare const STANDARDS_VERSION = "4.2.0";
 declare const STANDARDS_SCHEMA_VERSION = 4;
 
 /** Load the master spec JSON from the packaged dist directory */

package/dist/index.d.ts

@@ -156,7 +156,7 @@ interface StackChecklistJson {
  * Consumers should import from here instead of package.json to avoid
  * ESM/CJS interop issues.
  */
-declare const STANDARDS_VERSION = "4.1.0";
+declare const STANDARDS_VERSION = "4.2.0";
 declare const STANDARDS_SCHEMA_VERSION = 4;
 
 /** Load the master spec JSON from the packaged dist directory */

package/dist/index.js

@@ -4,7 +4,7 @@ import { readFileSync } from "fs";
 import { join, dirname } from "path";
 
 // src/version.ts
-var STANDARDS_VERSION = "4.1.0";
+var STANDARDS_VERSION = "4.2.0";
 var STANDARDS_SCHEMA_VERSION = 4;
 
 // src/index.ts

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/version.ts"],"sourcesContent":["import { fileURLToPath } from \"node:url\";\nimport { readFileSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport type {\n  MasterJson,\n  StackChecklistJson,\n  StackId,\n  CiSystem,\n} from \"./types.js\";\nimport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION } from \"./version.js\";\n\n// Re-export types for consumers\nexport type { MasterJson, StackChecklistJson, StackId, CiSystem };\n\n// Re-export version info (stable API contract)\nexport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION };\n\n// ESM equivalent of __dirname\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n// Path to config directory:\n// - When running from src/ (dev/test): use repo root config/\n// - When running from dist/ (installed): use dist/config/\nconst isDevMode = __dirname.includes(\"src\");\nconst configDir = isDevMode\n  ? join(__dirname, \"..\", \"config\")\n  : join(__dirname, \"config\");\n\n/** Load the master spec JSON from the packaged dist directory */\nexport function loadMasterSpec(): MasterJson {\n  const filePath = join(configDir, \"standards.json\");\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** Load a stack-specific checklist (optionally filtered by CI system) */\nexport function loadBaseline(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  const suffix = ci ? `.${ci}` : \"\";\n  const file = `standards.${stack}${suffix}.json`;\n  const filePath = join(configDir, file);\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** List all supported stacks (derived from the master spec) */\nexport function listSupportedStacks(): readonly StackId[] {\n  const spec = loadMasterSpec();\n  return Object.keys(spec.stacks) as StackId[];\n}\n\n/** List all supported CI systems (derived from the master spec) */\nexport function listSupportedCiSystems(): readonly CiSystem[] {\n  const spec = loadMasterSpec();\n  return spec.ciSystems as CiSystem[];\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadBaseline - loads stack-specific standards checklist.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getStandards(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  return loadBaseline(stack, ci);\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadMasterSpec - loads the master standards schema.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getSchema(): MasterJson {\n  return loadMasterSpec();\n}\n","/**\n * AUTO-GENERATED at build time by scripts/build.ts\n * DO NOT EDIT MANUALLY\n *\n * This module provides version information for the repo-standards package.\n * Consumers should import from here instead of package.json to avoid\n * ESM/CJS interop issues.\n */\n\nexport const STANDARDS_VERSION = '4.1.0';\nexport const STANDARDS_SCHEMA_VERSION = 4;\n"],"mappings":";AAAA,SAAS,qBAAqB;AAC9B,SAAS,oBAAoB;AAC7B,SAAS,MAAM,eAAe;;;ACOvB,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;;;ADQxC,IAAMA,cAAa,cAAc,YAAY,GAAG;AAChD,IAAMC,aAAY,QAAQD,WAAU;AAKpC,IAAM,YAAYC,WAAU,SAAS,KAAK;AAC1C,IAAM,YAAY,YACd,KAAKA,YAAW,MAAM,QAAQ,IAC9B,KAAKA,YAAW,QAAQ;AAGrB,SAAS,iBAA6B;AAC3C,QAAM,WAAW,KAAK,WAAW,gBAAgB;AACjD,SAAO,KAAK,MAAM,aAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,aACd,OACA,IACoB;AACpB,QAAM,SAAS,KAAK,IAAI,EAAE,KAAK;AAC/B,QAAM,OAAO,aAAa,KAAK,GAAG,MAAM;AACxC,QAAM,WAAW,KAAK,WAAW,IAAI;AACrC,SAAO,KAAK,MAAM,aAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,sBAA0C;AACxD,QAAM,OAAO,eAAe;AAC5B,SAAO,OAAO,KAAK,KAAK,MAAM;AAChC;AAGO,SAAS,yBAA8C;AAC5D,QAAM,OAAO,eAAe;AAC5B,SAAO,KAAK;AACd;AAOO,SAAS,aACd,OACA,IACoB;AACpB,SAAO,aAAa,OAAO,EAAE;AAC/B;AAOO,SAAS,YAAwB;AACtC,SAAO,eAAe;AACxB;","names":["__filename","__dirname"]}
+{"version":3,"sources":["../src/index.ts","../src/version.ts"],"sourcesContent":["import { fileURLToPath } from \"node:url\";\nimport { readFileSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport type {\n  MasterJson,\n  StackChecklistJson,\n  StackId,\n  CiSystem,\n} from \"./types.js\";\nimport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION } from \"./version.js\";\n\n// Re-export types for consumers\nexport type { MasterJson, StackChecklistJson, StackId, CiSystem };\n\n// Re-export version info (stable API contract)\nexport { STANDARDS_VERSION, STANDARDS_SCHEMA_VERSION };\n\n// ESM equivalent of __dirname\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n// Path to config directory:\n// - When running from src/ (dev/test): use repo root config/\n// - When running from dist/ (installed): use dist/config/\nconst isDevMode = __dirname.includes(\"src\");\nconst configDir = isDevMode\n  ? join(__dirname, \"..\", \"config\")\n  : join(__dirname, \"config\");\n\n/** Load the master spec JSON from the packaged dist directory */\nexport function loadMasterSpec(): MasterJson {\n  const filePath = join(configDir, \"standards.json\");\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** Load a stack-specific checklist (optionally filtered by CI system) */\nexport function loadBaseline(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  const suffix = ci ? `.${ci}` : \"\";\n  const file = `standards.${stack}${suffix}.json`;\n  const filePath = join(configDir, file);\n  return JSON.parse(readFileSync(filePath, \"utf8\"));\n}\n\n/** List all supported stacks (derived from the master spec) */\nexport function listSupportedStacks(): readonly StackId[] {\n  const spec = loadMasterSpec();\n  return Object.keys(spec.stacks) as StackId[];\n}\n\n/** List all supported CI systems (derived from the master spec) */\nexport function listSupportedCiSystems(): readonly CiSystem[] {\n  const spec = loadMasterSpec();\n  return spec.ciSystems as CiSystem[];\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadBaseline - loads stack-specific standards checklist.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getStandards(\n  stack: StackId,\n  ci?: CiSystem,\n): StackChecklistJson {\n  return loadBaseline(stack, ci);\n}\n\n/**\n * PUBLIC API CONTRACT (semver-governed)\n * Alias for loadMasterSpec - loads the master standards schema.\n * Breaking changes to this function signature require a major version bump.\n */\nexport function getSchema(): MasterJson {\n  return loadMasterSpec();\n}\n","/**\n * AUTO-GENERATED at build time by scripts/build.ts\n * DO NOT EDIT MANUALLY\n *\n * This module provides version information for the repo-standards package.\n * Consumers should import from here instead of package.json to avoid\n * ESM/CJS interop issues.\n */\n\nexport const STANDARDS_VERSION = '4.2.0';\nexport const STANDARDS_SCHEMA_VERSION = 4;\n"],"mappings":";AAAA,SAAS,qBAAqB;AAC9B,SAAS,oBAAoB;AAC7B,SAAS,MAAM,eAAe;;;ACOvB,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;;;ADQxC,IAAMA,cAAa,cAAc,YAAY,GAAG;AAChD,IAAMC,aAAY,QAAQD,WAAU;AAKpC,IAAM,YAAYC,WAAU,SAAS,KAAK;AAC1C,IAAM,YAAY,YACd,KAAKA,YAAW,MAAM,QAAQ,IAC9B,KAAKA,YAAW,QAAQ;AAGrB,SAAS,iBAA6B;AAC3C,QAAM,WAAW,KAAK,WAAW,gBAAgB;AACjD,SAAO,KAAK,MAAM,aAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,aACd,OACA,IACoB;AACpB,QAAM,SAAS,KAAK,IAAI,EAAE,KAAK;AAC/B,QAAM,OAAO,aAAa,KAAK,GAAG,MAAM;AACxC,QAAM,WAAW,KAAK,WAAW,IAAI;AACrC,SAAO,KAAK,MAAM,aAAa,UAAU,MAAM,CAAC;AAClD;AAGO,SAAS,sBAA0C;AACxD,QAAM,OAAO,eAAe;AAC5B,SAAO,OAAO,KAAK,KAAK,MAAM;AAChC;AAGO,SAAS,yBAA8C;AAC5D,QAAM,OAAO,eAAe;AAC5B,SAAO,KAAK;AACd;AAOO,SAAS,aACd,OACA,IACoB;AACpB,SAAO,aAAa,OAAO,EAAE;AAC/B;AAOO,SAAS,YAAwB;AACtC,SAAO,eAAe;AACxB;","names":["__filename","__dirname"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oddessentials/repo-standards",
   "private": false,
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Standards and CI filtering utilities for multi-stack repository governance.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "prepare": "husky",
+    "postinstall": "git config core.hooksPath .husky || true",
     "ci": "npm run lint && npm run format:check && npm run typecheck && npm run test && npm run build",
     "generate:standards": "tsx scripts/generate-standards.ts",
     "validate:schema": "tsx scripts/validate-schema.ts",
@@ -53,10 +54,10 @@
     "node": ">=22 <23"
   },
   "lint-staged": {
-    "*.{js,ts,mjs,json,md}": [
+    "*.{js,cjs,ts,mjs,json,md}": [
       "prettier --write"
     ],
-    "*.{js,ts,mjs}": [
+    "*.{js,cjs,ts,mjs}": [
       "eslint --fix"
     ]
   },
@@ -92,6 +93,7 @@
   "files": [
     "dist/",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "scripts/"
   ]
 }

package/scripts/build.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env tsx
+// scripts/build.ts
+
+/**
+ * Build script for @oddessentials/repo-standards
+ * - Copies master config/standards.json to dist/config/
+ * - Generates stack-specific JSON artifacts into dist/config/
+ * - Ensures deterministic output (sorted keys, no timestamps)
+ */
+
+import { execSync } from "node:child_process";
+import {
+  writeFileSync,
+  readFileSync,
+  mkdirSync,
+  copyFileSync,
+  readdirSync,
+} from "node:fs";
+import { resolve, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+
+// Helper to sort object keys recursively for deterministic output
+function sortObject(obj: unknown): unknown {
+  if (Array.isArray(obj)) return obj.map(sortObject);
+  if (obj && typeof obj === "object") {
+    const sorted: Record<string, unknown> = {};
+    Object.keys(obj as Record<string, unknown>)
+      .sort()
+      .forEach((key) => {
+        sorted[key] = sortObject((obj as Record<string, unknown>)[key]);
+      });
+    return sorted;
+  }
+  return obj;
+}
+/**
+ * Ensure schema version matches package.json major version.
+ * - Auto-upgrades schema when package.json major is higher (for semantic-release)
+ * - Fails if schema is ahead of package (prevents manual drift)
+ */
+function syncSchemaVersion(rootDir: string): void {
+  const pkgPath = join(rootDir, "package.json");
+  const standardsPath = join(rootDir, "config", "standards.json");
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const standards = JSON.parse(readFileSync(standardsPath, "utf8"));
+
+  // Extract major version from package.json (e.g., "2.1.0" -> 2)
+  const pkgMajor = parseInt(pkg.version.split(".")[0], 10);
+
+  if (pkgMajor > standards.version) {
+    // Auto-upgrade schema version when semantic-release bumps package.json
+    console.log(
+      `Upgrading schema version: ${standards.version} -> ${pkgMajor} (from package.json)`,
+    );
+    standards.version = pkgMajor;
+    writeFileSync(standardsPath, JSON.stringify(standards, null, 2) + "\n");
+  } else if (standards.version > pkgMajor) {
+    // Schema ahead of package = manual drift, fail build
+    throw new Error(
+      `Schema version drift: standards.json version=${standards.version} ` +
+        `is ahead of package.json major=${pkgMajor}. ` +
+        `This should not happen - schema version is set by CI.`,
+    );
+  } else {
+    console.log(
+      `Schema version ${standards.version} matches package.json major`,
+    );
+  }
+}
+
+// Run the existing generator for each stack (and optional CI system)
+function generateStack(stack: string, ci?: string) {
+  const args = ["scripts/generate-standards.ts", stack];
+  if (ci) args.push(ci);
+  const cmd = `npx tsx ${args.join(" ")}`;
+  console.log(`Generating ${stack}${ci ? " for " + ci : ""}`);
+  execSync(cmd, { stdio: "inherit" });
+}
+
+/**
+ * Generate src/version.ts with current package version
+ * This runs before TypeScript compilation so the values are baked in
+ */
+function generateVersionFile(rootDir: string): void {
+  const pkgPath = join(rootDir, "package.json");
+  const versionPath = join(rootDir, "src", "version.ts");
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const standards = JSON.parse(
+    readFileSync(join(rootDir, "config", "standards.json"), "utf8"),
+  );
+
+  const content = `/**
+ * AUTO-GENERATED at build time by scripts/build.ts
+ * DO NOT EDIT MANUALLY
+ *
+ * This module provides version information for the repo-standards package.
+ * Consumers should import from here instead of package.json to avoid
+ * ESM/CJS interop issues.
+ */
+
+export const STANDARDS_VERSION = '${pkg.version}';
+export const STANDARDS_SCHEMA_VERSION = ${standards.version};
+`;
+
+  writeFileSync(versionPath, content);
+  console.log(`Generated src/version.ts with version ${pkg.version}`);
+}
+
+function main() {
+  const rootDir = process.cwd();
+  const configSrc = resolve(rootDir, "config");
+  const configDest = resolve(rootDir, "dist", "config");
+
+  // Generate version.ts before TypeScript compilation
+  generateVersionFile(rootDir);
+
+  // Sync schema version with package.json major version (before generation)
+  syncSchemaVersion(rootDir);
+
+  // Ensure dist/config exists
+  mkdirSync(configDest, { recursive: true });
+
+  // Copy master standards.json first
+  copyFileSync(
+    join(configSrc, "standards.json"),
+    join(configDest, "standards.json"),
+  );
+  console.log("Copied master standards.json to dist/config/");
+
+  const stacks = ["typescript-js", "csharp-dotnet", "python", "rust", "go"];
+  const ciSystems = ["azure-devops", "github-actions"];
+
+  // Generate each stack without CI suffix
+  for (const stack of stacks) {
+    generateStack(stack);
+  }
+
+  // Generate CI-specific views
+  for (const stack of stacks) {
+    for (const ci of ciSystems) {
+      generateStack(stack, ci);
+    }
+  }
+
+  // Copy all generated files from config/ to dist/config/
+  const generatedFiles = readdirSync(configSrc).filter(
+    (f) => f.startsWith("standards.") && f.endsWith(".json"),
+  );
+
+  for (const file of generatedFiles) {
+    const srcPath = join(configSrc, file);
+    const destPath = join(configDest, file);
+
+    // Read, sort for determinism, and write
+    const data = JSON.parse(readFileSync(srcPath, "utf8"));
+    const sorted = sortObject(data);
+    writeFileSync(destPath, JSON.stringify(sorted, null, 2) + "\n");
+  }
+
+  console.log(
+    `Build complete – ${generatedFiles.length} artifacts written to dist/config/`,
+  );
+}
+
+// ESM entrypoint check
+if (process.argv[1] === __filename) {
+  main();
+}

package/scripts/detect-bazel.test.ts

@@ -0,0 +1,61 @@
+// scripts/detect-bazel.test.ts
+
+import { describe, it, expect } from "vitest";
+import { detectBazel } from "./detect-bazel.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixtures = path.resolve(__dirname, "..", "test", "fixtures");
+
+describe("detectBazel", () => {
+  it("detects bzlmod repo via MODULE.bazel", () => {
+    const result = detectBazel(path.join(fixtures, "bzlmod-repo"));
+    expect(result.detected).toBe(true);
+    expect(result.mode).toBe("bzlmod");
+    expect(result.markers).toContain("MODULE.bazel");
+  });
+
+  it("detects .bazelversion as optional marker", () => {
+    const result = detectBazel(path.join(fixtures, "bzlmod-repo"));
+    expect(result.markers).toContain(".bazelversion");
+  });
+
+  it("detects workspace repo via WORKSPACE.bazel", () => {
+    const result = detectBazel(path.join(fixtures, "workspace-repo"));
+    expect(result.detected).toBe(true);
+    expect(result.mode).toBe("workspace");
+    expect(result.markers).toContain("WORKSPACE.bazel");
+  });
+
+  it("does NOT detect non-Bazel repo (regression)", () => {
+    const result = detectBazel(path.join(fixtures, "no-bazel-repo"));
+    expect(result.detected).toBe(false);
+    expect(result.mode).toBeUndefined();
+    expect(result.markers).toHaveLength(0);
+  });
+
+  it("detects hybrid monorepo at root level only", () => {
+    const result = detectBazel(path.join(fixtures, "hybrid-monorepo"));
+    expect(result.detected).toBe(true);
+    expect(result.mode).toBe("bzlmod");
+    expect(result.markers).toContain("MODULE.bazel");
+    // Does NOT include nested BUILD files in markers
+    expect(result.markers).not.toContain("apps/web/BUILD.bazel");
+    expect(result.markers).not.toContain("libs/vendored/BUILD.bazel");
+  });
+
+  it("prefers bzlmod over workspace when MODULE.bazel exists", () => {
+    // The bzlmod-repo fixture has MODULE.bazel, should be detected as bzlmod
+    const result = detectBazel(path.join(fixtures, "bzlmod-repo"));
+    expect(result.mode).toBe("bzlmod");
+  });
+
+  it("does NOT detect Bazel when only nested BUILD files exist (no root markers)", () => {
+    // This validates the documented contract: detection uses repo-root markers only
+    const result = detectBazel(path.join(fixtures, "nested-build-only"));
+    expect(result.detected).toBe(false);
+    expect(result.mode).toBeUndefined();
+    expect(result.markers).toHaveLength(0);
+  });
+});

package/scripts/detect-bazel.ts

@@ -0,0 +1,82 @@
+// scripts/detect-bazel.ts
+
+/**
+ * Standalone Bazel detection utility.
+ * Does NOT require Bazel to be installed.
+ * Only checks repo-root markers to avoid false positives from vendored deps.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+export interface BazelDetectionResult {
+  /** Whether Bazel markers were detected at repo root */
+  detected: boolean;
+  /** Bazel mode: bzlmod (MODULE.bazel) or workspace (WORKSPACE*) */
+  mode?: "bzlmod" | "workspace";
+  /** List of detected marker files */
+  markers: string[];
+}
+
+/** Root-level markers that indicate a Bazel repo */
+const ROOT_MARKERS = {
+  bzlmod: ["MODULE.bazel"],
+  workspace: ["WORKSPACE.bazel", "WORKSPACE"],
+};
+
+/** Optional markers that support Bazel but don't trigger detection alone */
+const OPTIONAL_MARKERS = [".bazelrc", ".bazelversion"];
+
+/**
+ * Detect Bazel at repo root only.
+ * Does NOT scan subdirectories for BUILD files (avoids vendored deps false positives).
+ *
+ * @param repoRoot - Absolute path to repository root
+ * @returns Detection result with mode and found markers
+ */
+export function detectBazel(repoRoot: string): BazelDetectionResult {
+  const foundMarkers: string[] = [];
+  let mode: "bzlmod" | "workspace" | undefined;
+
+  // Check bzlmod first (preferred)
+  for (const marker of ROOT_MARKERS.bzlmod) {
+    if (fs.existsSync(path.join(repoRoot, marker))) {
+      foundMarkers.push(marker);
+      mode = "bzlmod";
+    }
+  }
+
+  // Check workspace if no bzlmod
+  if (!mode) {
+    for (const marker of ROOT_MARKERS.workspace) {
+      if (fs.existsSync(path.join(repoRoot, marker))) {
+        foundMarkers.push(marker);
+        mode = "workspace";
+        break; // Only need one workspace marker
+      }
+    }
+  }
+
+  // Check optional markers (don't affect detection, just informational)
+  for (const marker of OPTIONAL_MARKERS) {
+    if (fs.existsSync(path.join(repoRoot, marker))) {
+      foundMarkers.push(marker);
+    }
+  }
+
+  return {
+    detected: mode !== undefined,
+    mode,
+    markers: foundMarkers,
+  };
+}
+
+// CLI entrypoint for manual testing
+if (
+  import.meta.url.startsWith("file:") &&
+  process.argv[1]?.includes("detect-bazel")
+) {
+  const targetDir = process.argv[2] || process.cwd();
+  const result = detectBazel(path.resolve(targetDir));
+  console.log(JSON.stringify(result, null, 2));
+}

package/scripts/generate-instructions.ts

@@ -0,0 +1,174 @@
+// scripts/generate-instructions.ts
+//
+// Generates instructions.md from a stack+CI specific JSON file.
+// Usage: npx ts-node-esm scripts/generate-instructions.ts [config-file]
+// Example: npm run generate:instructions standards.python.github-actions.json
+// Default: config/standards.typescript-js.github-actions.json
+
+import fs from "node:fs";
+import path from "node:path";
+
+interface StackHints {
+  exampleTools?: string[];
+  exampleConfigFiles?: string[];
+  notes?: string;
+  verification?: string;
+  requiredFiles?: string[];
+  optionalFiles?: string[];
+  requiredScripts?: string[];
+}
+
+interface ChecklistItem {
+  id: string;
+  label: string;
+  description: string;
+  ciHints?: Record<string, { job?: string; stage?: string }>;
+  stack?: StackHints;
+}
+
+interface StackChecklistJson {
+  version: number;
+  stack: string;
+  stackLabel: string;
+  ciSystems: string[];
+  checklist: {
+    core: ChecklistItem[];
+    recommended: ChecklistItem[];
+    optionalEnhancements: ChecklistItem[];
+  };
+}
+
+/**
+ * Generate 2-5 high-level bullets from a checklist item.
+ */
+function generateBullets(item: ChecklistItem): string[] {
+  const bullets: string[] = [];
+  const stack = item.stack;
+
+  // Bullet 1: Core purpose from description
+  bullets.push(item.description);
+
+  // Bullet 2: Required files if any
+  if (stack?.requiredFiles?.length) {
+    const files = stack.requiredFiles.join(", ");
+    bullets.push(`Ensure ${files} exists in the repository.`);
+  }
+
+  // Bullet 3: Optional files mention
+  if (stack?.optionalFiles?.length) {
+    const files = stack.optionalFiles.slice(0, 3).join(", ");
+    const more = stack.optionalFiles.length > 3 ? " and others" : "";
+    bullets.push(`Consider adding ${files}${more} if applicable.`);
+  }
+
+  // Bullet 4: Required scripts
+  if (stack?.requiredScripts?.length) {
+    const scripts = stack.requiredScripts.map((s) => `\`${s}\``).join(", ");
+    bullets.push(`Define a ${scripts} script or equivalent command.`);
+  }
+
+  // Bullet 5: Notes-based guidance (if short enough)
+  if (stack?.notes && stack.notes.length < 150) {
+    bullets.push(stack.notes);
+  }
+
+  // Limit to 5 bullets
+  return bullets.slice(0, 5);
+}
+
+function generateSection(title: string, items: ChecklistItem[]): string {
+  if (items.length === 0) return "";
+
+  const lines: string[] = [];
+  lines.push(`## ${title}`);
+  lines.push("");
+
+  for (const item of items) {
+    lines.push(`### ${item.label}`);
+    lines.push("");
+
+    const bullets = generateBullets(item);
+    for (const bullet of bullets) {
+      lines.push(`- ${bullet}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function main() {
+  const rootDir = process.cwd();
+
+  // Accept config file as CLI argument, default to TypeScript+GitHub Actions
+  const configArg = process.argv[2];
+  let inputPath: string;
+
+  if (configArg) {
+    // If argument provided, resolve relative to config/ or as absolute
+    if (path.isAbsolute(configArg)) {
+      inputPath = configArg;
+    } else if (
+      configArg.startsWith("config/") ||
+      configArg.startsWith("config\\")
+    ) {
+      inputPath = path.join(rootDir, configArg);
+    } else {
+      inputPath = path.join(rootDir, "config", configArg);
+    }
+  } else {
+    inputPath = path.join(
+      rootDir,
+      "config",
+      "standards.typescript-js.github-actions.json",
+    );
+  }
+
+  // Derive output filename from input (e.g., standards.python.json -> instructions.python.md)
+  const inputBasename = path.basename(inputPath, ".json");
+  const outputBasename = inputBasename.replace(/^standards\./, "instructions.");
+  const outputPath = path.join(rootDir, `${outputBasename}.md`);
+
+  if (!fs.existsSync(inputPath)) {
+    console.error(`Input file not found: ${inputPath}`);
+    console.error("Usage: npm run generate:instructions [config-file]");
+    console.error(
+      "Example: npm run generate:instructions standards.python.github-actions.json",
+    );
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(inputPath, "utf8");
+  const data: StackChecklistJson = JSON.parse(raw);
+
+  const lines: string[] = [];
+
+  // Header
+  lines.push("# Repository Standards Instructions");
+  lines.push("");
+  lines.push(`> Auto-generated from \`${path.relative(rootDir, inputPath)}\``);
+  lines.push(`> Stack: ${data.stackLabel} | CI: ${data.ciSystems.join(", ")}`);
+  lines.push("");
+  lines.push(
+    "This document provides high-level guidance for an autonomous coding agent to bring a repository into compliance with the defined standards.",
+  );
+  lines.push("");
+
+  // Generate sections
+  lines.push(generateSection("Core Requirements", data.checklist.core));
+  lines.push(
+    generateSection("Recommended Practices", data.checklist.recommended),
+  );
+  lines.push(
+    generateSection(
+      "Optional Enhancements",
+      data.checklist.optionalEnhancements,
+    ),
+  );
+
+  // Write output
+  fs.writeFileSync(outputPath, lines.join("\n"));
+  console.log(`Wrote ${outputPath}`);
+}
+
+main();

package/scripts/generate-standards.ts

@@ -0,0 +1,247 @@
+// scripts/generate-standards.ts
+
+import fs from "node:fs";
+import path from "node:path";
+
+type StackId = "typescript-js" | "csharp-dotnet" | "python" | "rust" | "go";
+type CiSystem = "azure-devops" | "github-actions";
+
+interface StackMeta {
+  label: string;
+  languageFamily: string;
+}
+
+interface CiHintsForSystem {
+  stage?: string;
+  job?: string;
+}
+
+type CiHints = Partial<Record<CiSystem, CiHintsForSystem>>;
+
+/**
+ * Bazel execution hints for individual checklist items.
+ * Commands are actual Bazel invocations (e.g., "bazel test //..."),
+ * NOT assumed pattern labels.
+ */
+interface BazelHints {
+  /** Bazel commands to run (e.g., "bazel test //...", "bazel run //tools/lint") */
+  commands?: string[];
+  /** Recommended target conventions (documentation only, not assumed to exist) */
+  recommendedTargets?: string[];
+  /** Usage notes for this check in Bazel context */
+  notes?: string;
+}
+
+interface StackHints {
+  exampleTools?: string[];
+  exampleConfigFiles?: string[];
+  notes?: string;
+  // Human‑readable verification instructions
+  verification?: string;
+  // Machine‑readable additions (all optional)
+  requiredFiles?: string[];
+  optionalFiles?: string[];
+  requiredScripts?: string[];
+  // Either-or file compliance: at least one of these files must exist
+  anyOfFiles?: string[];
+  // Version pinning guidance for deterministic CI
+  pinningNotes?: string;
+  machineCheck?: {
+    command: string;
+    expectExitCode?: number;
+    description?: string;
+  };
+  // Bazel execution hints (v3+)
+  bazelHints?: BazelHints;
+}
+
+interface ChecklistItemMaster {
+  id: string;
+  label: string;
+  description: string;
+  appliesTo: {
+    stacks: StackId[];
+    ciSystems?: CiSystem[];
+  };
+  ciHints?: CiHints;
+  stackHints?: Partial<Record<StackId, StackHints>>;
+}
+
+interface ChecklistSection {
+  core: ChecklistItemMaster[];
+  recommended: ChecklistItemMaster[];
+  optionalEnhancements: ChecklistItemMaster[];
+}
+
+interface MigrationStep {
+  step: number;
+  title: string;
+  description: string;
+  focusIds?: string[];
+  notes?: string;
+}
+
+interface Meta {
+  defaultCoverageThreshold?: number;
+  complexityChecks?: {
+    enabledByDefault?: boolean;
+    description?: string;
+  };
+  qualityGatePolicy?: {
+    preferSoftFailOnLegacy?: boolean;
+    description?: string;
+  };
+  migrationGuide?: MigrationStep[];
+}
+
+interface MasterJson {
+  version: number;
+  meta?: Meta;
+  ciSystems: CiSystem[];
+  stacks: Record<StackId, StackMeta>;
+  checklist: ChecklistSection;
+}
+
+interface StackItem {
+  id: string;
+  label: string;
+  description: string;
+  ciHints?: CiHints;
+  // For the filtered file, this is the single stack’s hints including verification
+  stack?: StackHints;
+}
+
+interface StackChecklistJson {
+  version: number;
+  stack: StackId;
+  stackLabel: string;
+  ciSystems: CiSystem[];
+  meta?: Meta;
+  checklist: {
+    core: StackItem[];
+    recommended: StackItem[];
+    optionalEnhancements: StackItem[];
+  };
+}
+
+function filterSectionForStackAndCi(
+  items: ChecklistItemMaster[],
+  stack: StackId,
+  ciSystem?: CiSystem,
+): StackItem[] {
+  return items
+    .filter((item) => {
+      if (!item.appliesTo.stacks.includes(stack)) return false;
+
+      if (ciSystem && item.appliesTo.ciSystems) {
+        return item.appliesTo.ciSystems.includes(ciSystem);
+      }
+      return true;
+    })
+    .map((item) => {
+      const stackHint = item.stackHints?.[stack];
+
+      const result: StackItem = {
+        id: item.id,
+        label: item.label,
+        description: item.description,
+      };
+
+      if (item.ciHints) {
+        if (ciSystem) {
+          const perSystem = item.ciHints[ciSystem];
+          if (perSystem) {
+            result.ciHints = { [ciSystem]: perSystem };
+          }
+        } else {
+          result.ciHints = item.ciHints;
+        }
+      }
+
+      if (stackHint) {
+        // Includes exampleTools, exampleConfigFiles, notes, verification
+        result.stack = stackHint;
+      }
+
+      return result;
+    });
+}
+
+function generateStackJson(
+  master: MasterJson,
+  stack: StackId,
+  ciSystem?: CiSystem,
+): StackChecklistJson {
+  const stackMeta = master.stacks[stack];
+  const ciSystems = ciSystem ? [ciSystem] : master.ciSystems;
+
+  return {
+    version: master.version,
+    stack,
+    stackLabel: stackMeta?.label ?? stack,
+    ciSystems,
+    meta: master.meta,
+    checklist: {
+      core: filterSectionForStackAndCi(master.checklist.core, stack, ciSystem),
+      recommended: filterSectionForStackAndCi(
+        master.checklist.recommended,
+        stack,
+        ciSystem,
+      ),
+      optionalEnhancements: filterSectionForStackAndCi(
+        master.checklist.optionalEnhancements,
+        stack,
+        ciSystem,
+      ),
+    },
+  };
+}
+
+// --- entrypoint ---
+const rootDir = path.join(process.cwd());
+const masterPath = path.join(rootDir, "config", "standards.json");
+
+const raw = fs.readFileSync(masterPath, "utf8");
+const master: MasterJson = JSON.parse(raw);
+
+// args: stack [ciSystem]
+// args: stack [ciSystem]
+const STACK_ALIASES: Record<string, StackId> = {
+  dotnet: "csharp-dotnet",
+  csharp: "csharp-dotnet",
+  ts: "typescript-js",
+  js: "typescript-js",
+  python: "python",
+  py: "python",
+  "typescript-js": "typescript-js",
+  "csharp-dotnet": "csharp-dotnet",
+  rust: "rust",
+  rs: "rust",
+  go: "go",
+  golang: "go",
+};
+
+const rawArg = process.argv[2] || "typescript-js";
+const targetStack = STACK_ALIASES[rawArg.toLowerCase()];
+
+if (!targetStack) {
+  console.error(`Unknown stack: ${rawArg}`);
+  console.error(
+    `Available stacks: ${["typescript-js", "csharp-dotnet", "python", "rust", "go"].join(", ")}`,
+  );
+  process.exit(1);
+}
+
+const targetCiSystem = process.argv[3] as CiSystem | undefined;
+
+const stackJson = generateStackJson(master, targetStack, targetCiSystem);
+
+const outDir = path.join(rootDir, "config");
+fs.mkdirSync(outDir, { recursive: true });
+
+const ciSuffix = targetCiSystem ? `.${targetCiSystem}` : "";
+const outPath = path.join(outDir, `standards.${targetStack}${ciSuffix}.json`);
+
+fs.writeFileSync(outPath, JSON.stringify(stackJson, null, 2) + "\n");
+
+console.log(`Wrote ${outPath}`);

package/scripts/sync-manifest-version.cjs

@@ -0,0 +1,32 @@
+/**
+ * Syncs manifest.json version with package.json
+ * Called by semantic-release exec plugin during release
+ *
+ * @see https://github.com/semantic-release/exec
+ */
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const pkgPath = path.join(process.cwd(), "package.json");
+const manifestPath = path.join(process.cwd(), "manifest.json");
+
+if (!fs.existsSync(manifestPath)) {
+  console.log("[sync-manifest] No manifest.json found, skipping");
+  process.exit(0);
+}
+
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+
+manifest.version = pkg.version;
+fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+
+// Run prettier to ensure consistent formatting
+try {
+  execSync("npx prettier --write manifest.json", { stdio: "inherit" });
+} catch {
+  console.log("[sync-manifest] prettier not available, skipping format");
+}
+
+console.log(`[sync-manifest] Updated manifest.json to ${pkg.version}`);

package/scripts/validate-schema.ts

@@ -0,0 +1,289 @@
+// scripts/validate-schema.ts
+// Validates standards.json against JSON Schema and performs additional semantic checks
+
+import Ajv, { ErrorObject } from "ajv";
+import addFormats from "ajv-formats";
+import stableStringify from "fast-json-stable-stringify";
+import fs from "node:fs";
+import path from "node:path";
+
+const rootDir = process.cwd();
+const configPath = path.join(rootDir, "config", "standards.json");
+const schemaPath = path.join(rootDir, "config", "standards.schema.json");
+
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+interface ChecklistItem {
+  id: string;
+  appliesTo?: { stacks?: string[]; ciSystems?: string[] };
+  ciHints?: Record<string, unknown>;
+  stackHints?: Record<string, unknown>;
+}
+
+interface MigrationStep {
+  focusIds?: string[];
+}
+
+interface Config {
+  version: number;
+  ciSystems: string[];
+  stacks: Record<string, unknown>;
+  meta?: {
+    defaultCoverageThreshold?: number;
+    coverageThresholdUnit?: string;
+    migrationGuide?: MigrationStep[];
+  };
+  checklist: {
+    core: ChecklistItem[];
+    recommended: ChecklistItem[];
+    optionalEnhancements: ChecklistItem[];
+  };
+}
+
+/**
+ * Validate config against JSON Schema using Ajv
+ */
+function validateSchema(config: unknown, schema: unknown): ValidationResult {
+  const ajv = new Ajv.default({ allErrors: true, strict: true });
+  addFormats.default(ajv);
+
+  const validate = ajv.compile(schema as object);
+  const valid = validate(config);
+
+  if (!valid && validate.errors) {
+    return {
+      valid: false,
+      errors: validate.errors.map(
+        (e: ErrorObject) =>
+          `${e.instancePath || "/"}: ${e.message} (${JSON.stringify(e.params)})`,
+      ),
+    };
+  }
+
+  return { valid: true, errors: [] };
+}
+
+/**
+ * Validate that all checklist IDs are unique across all sections
+ */
+function validateUniqueIds(config: Config): ValidationResult {
+  const allItems = [
+    ...config.checklist.core,
+    ...config.checklist.recommended,
+    ...config.checklist.optionalEnhancements,
+  ];
+
+  const ids = allItems.map((item) => item.id);
+  const seen = new Set<string>();
+  const duplicates: string[] = [];
+
+  for (const id of ids) {
+    if (seen.has(id)) {
+      duplicates.push(id);
+    }
+    seen.add(id);
+  }
+
+  if (duplicates.length > 0) {
+    return {
+      valid: false,
+      errors: [`Duplicate checklist IDs found: ${duplicates.join(", ")}`],
+    };
+  }
+
+  return { valid: true, errors: [] };
+}
+
+/**
+ * Validate that migrationGuide focusIds reference existing checklist IDs
+ */
+function validateFocusIdReferences(config: Config): ValidationResult {
+  const allIds = new Set([
+    ...config.checklist.core.map((i) => i.id),
+    ...config.checklist.recommended.map((i) => i.id),
+    ...config.checklist.optionalEnhancements.map((i) => i.id),
+  ]);
+
+  const errors: string[] = [];
+  const migrationGuide = config.meta?.migrationGuide ?? [];
+
+  for (const step of migrationGuide) {
+    for (const focusId of step.focusIds ?? []) {
+      if (!allIds.has(focusId)) {
+        errors.push(
+          `migrationGuide focusId "${focusId}" does not reference a valid checklist ID`,
+        );
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Validate that appliesTo.stacks only references known stack keys
+ */
+function validateStackReferences(config: Config): ValidationResult {
+  const validStacks = new Set(Object.keys(config.stacks));
+  const errors: string[] = [];
+
+  const allItems = [
+    ...config.checklist.core,
+    ...config.checklist.recommended,
+    ...config.checklist.optionalEnhancements,
+  ];
+
+  for (const item of allItems) {
+    for (const stack of item.appliesTo?.stacks ?? []) {
+      if (!validStacks.has(stack)) {
+        errors.push(
+          `Item "${item.id}" references unknown stack "${stack}" in appliesTo.stacks`,
+        );
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Validate that ciHints keys are a subset of ciSystems
+ */
+function validateCiHintKeys(config: Config): ValidationResult {
+  const validCiSystems = new Set(config.ciSystems);
+  const errors: string[] = [];
+
+  const allItems = [
+    ...config.checklist.core,
+    ...config.checklist.recommended,
+    ...config.checklist.optionalEnhancements,
+  ];
+
+  for (const item of allItems) {
+    for (const ciKey of Object.keys(item.ciHints ?? {})) {
+      if (!validCiSystems.has(ciKey)) {
+        errors.push(
+          `Item "${item.id}" has ciHints key "${ciKey}" not in ciSystems`,
+        );
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Validate coverage threshold semantics: if unit is "ratio", threshold must be 0-1
+ */
+function validateCoverageThreshold(config: Config): ValidationResult {
+  const threshold = config.meta?.defaultCoverageThreshold;
+  const unit = config.meta?.coverageThresholdUnit;
+
+  if (unit === "ratio" && threshold !== undefined) {
+    if (threshold < 0 || threshold > 1) {
+      return {
+        valid: false,
+        errors: [
+          `defaultCoverageThreshold is ${threshold} but coverageThresholdUnit is "ratio" (must be 0-1)`,
+        ],
+      };
+    }
+  }
+
+  return { valid: true, errors: [] };
+}
+
+/**
+ * Generate a normalized, deterministic string representation of the config.
+ * Uses deep stable key ordering at all depths.
+ */
+export function normalizeConfig(config: unknown): string {
+  return stableStringify(config);
+}
+
+/**
+ * Run all validations and return combined result
+ */
+export function validateStandardsConfig(
+  configRaw: string,
+  schemaRaw: string,
+): ValidationResult {
+  let config: Config;
+  let schema: unknown;
+
+  try {
+    config = JSON.parse(configRaw);
+  } catch {
+    return { valid: false, errors: ["Failed to parse standards.json as JSON"] };
+  }
+
+  try {
+    schema = JSON.parse(schemaRaw);
+  } catch {
+    return {
+      valid: false,
+      errors: ["Failed to parse standards.schema.json as JSON"],
+    };
+  }
+
+  const results: ValidationResult[] = [
+    validateSchema(config, schema),
+    validateUniqueIds(config),
+    validateFocusIdReferences(config),
+    validateStackReferences(config),
+    validateCiHintKeys(config),
+    validateCoverageThreshold(config),
+  ];
+
+  const allErrors = results.flatMap((r) => r.errors);
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors,
+  };
+}
+
+/**
+ * Main entry point for CLI usage
+ */
+export function validateStandardsSchema(): void {
+  if (!fs.existsSync(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(schemaPath)) {
+    console.error(`Schema file not found: ${schemaPath}`);
+    process.exit(1);
+  }
+
+  const configRaw = fs.readFileSync(configPath, "utf8");
+  const schemaRaw = fs.readFileSync(schemaPath, "utf8");
+
+  const result = validateStandardsConfig(configRaw, schemaRaw);
+
+  if (!result.valid) {
+    console.error("Schema validation failed:");
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+
+  console.log("✓ Schema validation passed");
+  console.log("✓ All checklist IDs are unique");
+  console.log("✓ All migrationGuide focusIds reference valid IDs");
+  console.log("✓ All appliesTo.stacks reference valid stack keys");
+  console.log("✓ All ciHints keys are valid ciSystems");
+  console.log("✓ Coverage threshold semantics are valid");
+}
+
+// CLI entry point
+if (
+  import.meta.url.startsWith("file:") &&
+  process.argv[1]?.includes("validate-schema")
+) {
+  validateStandardsSchema();
+}