@xemahq/repo-build-tooling 0.8.1 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xemahq/repo-build-tooling",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Dev-time build tooling shared by every Xema repository. Ships as plain ESM with zero dependencies so the published artifact is the reviewed source.",
   "license": "Apache-2.0",
   "author": "Neuralchowder Inc. <developer@xema.dev> (https://xema.dev)",

package/src/readiness.mjs

@@ -439,10 +439,18 @@ export function packagesOwningPaths(root, relPaths, script = 'test') {
  *                     REPO-WIDE, labelled, because skipping would drop a proof.
  *   - `inapplicable`— nothing declares it. Genuinely nothing to run.
  */
-export function affectedStagePlan({ base, paths, packages, rootDeclares }) {
-  if (!base) return { mode: 'workspace', viaRoot: rootDeclares };
+export function affectedStagePlan({ base, paths, packages, rootDeclares, membersDeclare }) {
+  // REPO-WIDE means WHAT CI RUNS, and every CI in this fleet runs the stage as
+  // `pnpm -r --if-present run <script>` — per member, never the root script.
+  // Measured 2026-09-20 in xema-kernel-sdk: the root `lint` is `eslint .`,
+  // which also lints `tooling/**` and re-lints every package under the ROOT
+  // config, and reports 139 errors CI has never seen. Running it here made
+  // readiness a SECOND lint authority that disagreed with the first. The root
+  // script is used only where no member declares the stage at all.
+  if (!base) return { mode: 'workspace', viaRoot: rootDeclares && !membersDeclare };
   if (packages.length > 0) return { mode: 'affected', packages };
-  if (paths.length > 0 && rootDeclares) return { mode: 'root' };
+  if (paths.length > 0 && rootDeclares && !membersDeclare) return { mode: 'root' };
+  if (paths.length > 0 && membersDeclare) return { mode: 'workspace', viaRoot: false };
   return { mode: 'inapplicable' };
 }
 
@@ -455,6 +463,7 @@ function runAffectedStage({ id, script, why }) {
     paths,
     packages,
     rootDeclares: Boolean(scripts[script]),
+    membersDeclare: servicesWith(script).length > 0,
   });
   switch (plan.mode) {
     case 'workspace':
@@ -482,10 +491,9 @@ function runAffectedStage({ id, script, why }) {
       return;
     case 'root':
       // FALLBACK, and it is the difference between "inapplicable" and "not
-      // checked". Some repositories own a stage only at the root — `lint:
-      // eslint .` covers every package without any of them declaring `lint`.
-      // Skipping there would silently drop a real proof, so the root script
-      // runs, LABELLED as repo-wide rather than affected.
+      // checked": a repository that owns a stage ONLY at the root (no member
+      // declares it). Skipping there would silently drop a real proof, so the
+      // root script runs, LABELLED as repo-wide rather than affected.
       console.log(
         `  ${paths.length} changed path(s) since ${base.slice(0, 9)}; no changed` +
           ` package declares \`${script}\`, but the ROOT does — running it\n` +

package/src/readiness.test.mjs

@@ -218,28 +218,40 @@ test('an affected stage with NO branch point runs REPO-WIDE — it never skips',
   // The defect this pins: a scratch export or an archive has no origin/develop,
   // and the stage used to SKIP and let the run end "converged — safe to push"
   // with typecheck, lint and tests all unexecuted. Green over nothing.
+  // Members declare it: CI's `pnpm -r` form, even when the root ALSO has a
+  // script — the root's is a second authority (kernel-sdk's `eslint .`).
   assert.deepEqual(
-    affectedStagePlan({ base: undefined, paths: [], packages: [], rootDeclares: true }),
+    affectedStagePlan({ base: undefined, paths: [], packages: [], rootDeclares: true, membersDeclare: true }),
+    { mode: 'workspace', viaRoot: false },
+  );
+  // Only the root declares it: the root script is the only place it lives.
+  assert.deepEqual(
+    affectedStagePlan({ base: undefined, paths: [], packages: [], rootDeclares: true, membersDeclare: false }),
     { mode: 'workspace', viaRoot: true },
   );
   assert.deepEqual(
-    affectedStagePlan({ base: undefined, paths: [], packages: [], rootDeclares: false }),
+    affectedStagePlan({ base: undefined, paths: [], packages: [], rootDeclares: false, membersDeclare: false }),
     { mode: 'workspace', viaRoot: false },
   );
   // A base with owning packages is the ordinary affected run.
   assert.deepEqual(
-    affectedStagePlan({ base: 'abc', paths: ['a/x.ts'], packages: ['a'], rootDeclares: true }),
+    affectedStagePlan({ base: 'abc', paths: ['a/x.ts'], packages: ['a'], rootDeclares: true, membersDeclare: true }),
     { mode: 'affected', packages: ['a'] },
   );
   // A base where only the ROOT declares the script runs the root, labelled.
   assert.deepEqual(
-    affectedStagePlan({ base: 'abc', paths: ['README.md'], packages: [], rootDeclares: true }),
+    affectedStagePlan({ base: 'abc', paths: ['README.md'], packages: [], rootDeclares: true, membersDeclare: false }),
     { mode: 'root' },
   );
+  // A root-only path change where members own the stage: CI's form, not the root's.
+  assert.deepEqual(
+    affectedStagePlan({ base: 'abc', paths: ['README.md'], packages: [], rootDeclares: true, membersDeclare: true }),
+    { mode: 'workspace', viaRoot: false },
+  );
   // Nothing declares it: the only outcome that runs nothing, and it needs a
   // base to be trusted — without one it is the workspace run above.
   assert.deepEqual(
-    affectedStagePlan({ base: 'abc', paths: ['README.md'], packages: [], rootDeclares: false }),
+    affectedStagePlan({ base: 'abc', paths: ['README.md'], packages: [], rootDeclares: false, membersDeclare: false }),
     { mode: 'inapplicable' },
   );
 });