@pareto4/pp-core 1.20.0 → 1.21.1

package/scripts/gen-capability-registry.cjs

@@ -34,6 +34,12 @@ const SCHEMA_VERSION = '1';
 // registry generator and the loop-host-contract generator share one source of truth.
 const { LOOP_HOST_CONTRACT } = require('../pp-core/bin/lib/loop-host-contract.cjs');
 
+// Ceremony gate vocabulary (Phase 37, D-14) — a hook `when` conjunct `ceremony.<gate>`
+// must name a gate declared here.
+const CEREMONY_GATE_NAMES = new Set(
+  require('../pp-core/bin/shared/ceremony-gates.json').gates.map((g) => g.key),
+);
+
 // Wired-points helper — tells us which points actually have render-hooks call sites.
 const { getWiredLoopPoints } = require('./gen-loop-host-contract.cjs');
 
@@ -1241,6 +1247,38 @@ function validateGate(gate, prefix) {
 
 // ─── Contract validation ──────────────────────────────────────────────────────
 
+/**
+ * Validate a hook `when` (Phase 37, D-14). A `when` is one or more conjuncts joined
+ * by `&&`; each is a config key the capability declares, or `ceremony.<gate>` with
+ * the gate named in pp-core/bin/shared/ceremony-gates.json. A non-string `when` is
+ * already reported by the schema checks and is skipped here. Pushes onto `errors`.
+ * `where` is the message prefix, e.g. `capability "x" step.when`, so the message of
+ * a single undeclared key stays `<where> "<key>" is not defined in capability config keys`.
+ */
+function validateWhen(when, cap, where, errors) {
+  if (typeof when !== 'string') return;
+  for (const raw of when.split('&&')) {
+    const conjunct = raw.trim();
+    if (conjunct === '') {
+      errors.push(where + ' has an empty conjunct');
+      continue;
+    }
+    if (conjunct.startsWith('ceremony.')) {
+      if (!CEREMONY_GATE_NAMES.has(conjunct.slice('ceremony.'.length))) {
+        errors.push(where + ' "' + conjunct + '" is not a ceremony gate');
+      }
+      continue;
+    }
+    if (
+      typeof cap.config === 'object' &&
+      cap.config !== null &&
+      !Object.prototype.hasOwnProperty.call(cap.config, conjunct)
+    ) {
+      errors.push(where + ' "' + conjunct + '" is not defined in capability config keys');
+    }
+  }
+}
+
 /**
  * Validate per-capability contract constraints against the Loop Host Contract.
  * This covers:
@@ -1281,51 +1319,10 @@ function validateAgainstContract(cap, capId, knownAgentIds) {
     }
   }
 
-  // when references a plausibly-valid config key (string — we require it's in cap.config)
-  for (const step of cap.steps) {
-    if (step.when !== undefined) {
-      if (typeof step.when !== 'string') continue; // already reported above
-      if (
-        typeof cap.config === 'object' &&
-        cap.config !== null &&
-        !Object.prototype.hasOwnProperty.call(cap.config, step.when)
-      ) {
-        errors.push(
-          prefix + ' step.when "' + step.when + '" is not defined in capability config keys',
-        );
-      }
-    }
-  }
-
-  for (const contrib of cap.contributions) {
-    if (contrib.when !== undefined) {
-      if (typeof contrib.when !== 'string') continue;
-      if (
-        typeof cap.config === 'object' &&
-        cap.config !== null &&
-        !Object.prototype.hasOwnProperty.call(cap.config, contrib.when)
-      ) {
-        errors.push(
-          prefix + ' contribution.when "' + contrib.when + '" is not defined in capability config keys',
-        );
-      }
-    }
-  }
-
-  for (const gate of cap.gates) {
-    if (gate.when !== undefined) {
-      if (typeof gate.when !== 'string') continue;
-      if (
-        typeof cap.config === 'object' &&
-        cap.config !== null &&
-        !Object.prototype.hasOwnProperty.call(cap.config, gate.when)
-      ) {
-        errors.push(
-          prefix + ' gate.when "' + gate.when + '" is not defined in capability config keys',
-        );
-      }
-    }
-  }
+  // when: one or more `&&` conjuncts, each a declared config key or `ceremony.<gate>`
+  for (const step of cap.steps) validateWhen(step.when, cap, prefix + ' step.when', errors);
+  for (const contrib of cap.contributions) validateWhen(contrib.when, cap, prefix + ' contribution.when', errors);
+  for (const gate of cap.gates) validateWhen(gate.when, cap, prefix + ' gate.when', errors);
 
   return errors;
 }
@@ -2759,6 +2756,7 @@ function main() {
 module.exports = {
   validateCapability,
   validateAgainstContract,
+  validateWhen,
   validateConsumesGlobal,
   validateCrossCapability,
   validateSealField,

package/scripts/run-tests.cjs

@@ -31,7 +31,7 @@
 
 const { readdirSync } = require('fs');
 const { join, basename } = require('path');
-const { execFileSync } = require('child_process');
+const { execFileSync, spawnSync } = require('child_process');
 const { ExitError, runMain } = require('./lib/cli-exit.cjs');
 
 const SUITES = ['all', 'unit', 'integration', 'install', 'security', 'slow'];
@@ -548,42 +548,66 @@ function main() {
     if (chunks.length > 1) {
       console.error(`run-tests: chunk ${i + 1}/${chunks.length} — ${chunks[i].length} files`);
     }
-    try {
-      execFileSync(
-        process.execPath,
-        ['--test', ...(forceExit ? ['--test-force-exit'] : []), concurrency, ...chunks[i]],
-        {
-          stdio: 'inherit',
-          env: { ...process.env },
-          timeout: chunkTimeoutMs,
-        },
+    const chunkFiles = chunks[i].map(f => f.split(/[\\/]/).pop()).join(' ');
+    // stdout is captured, not inherited, so the chunk's node:test summary can be
+    // checked; it is written through unchanged once the chunk ends. stderr stays
+    // live. A chunk can exit 0 with its output cut off and no summary — on CI
+    // (2026-10-28) two of five chunks did, and ~1,000 tests never reported while
+    // the job stayed green — so a missing summary fails the run.
+    const result = spawnSync(
+      process.execPath,
+      ['--test', ...(forceExit ? ['--test-force-exit'] : []), concurrency, ...chunks[i]],
+      {
+        stdio: ['inherit', 'pipe', 'inherit'],
+        env: { ...process.env },
+        timeout: chunkTimeoutMs,
+        maxBuffer: 1024 * 1024 * 1024,
+      },
+    );
+    if (result.stdout && result.stdout.length > 0) process.stdout.write(result.stdout);
+    // When the per-chunk timeout fires, spawnSync kills the child and reports
+    // error.code === 'ETIMEDOUT' (POSIX) and/or a kill signal (platform-dependent).
+    // Check both so detection holds on Windows and POSIX.
+    const timedOut = (result.error && result.error.code === 'ETIMEDOUT') ||
+      (result.signal !== null && result.status === null && !result.error);
+    let code = result.status === null ? 1 : result.status;
+    if (result.error && result.error.code === 'ETIMEDOUT') code = 1;
+    if (timedOut) {
+      console.error(
+        `run-tests: chunk ${i + 1}/${chunks.length} exceeded the per-chunk timeout ` +
+          `of ${chunkTimeoutMs}ms and was killed — a test in this chunk is likely leaking ` +
+          `an open handle (un-terminated Worker, un-killed child process, or ref'd timer) ` +
+          `so node --test never exits. Files: ${chunkFiles}`,
       );
-    } catch (err) {
-      // When the per-chunk timeout fires, execFileSync kills the child and
-      // surfaces it as err.code === 'ETIMEDOUT' (POSIX) and/or err.killed === true
-      // (platform-dependent). Check both so detection holds on Windows and POSIX.
-      const timedOut = err.killed === true || err.code === 'ETIMEDOUT';
-      if (timedOut) {
-        console.error(
-          `run-tests: chunk ${i + 1}/${chunks.length} exceeded the per-chunk timeout ` +
-            `of ${chunkTimeoutMs}ms and was killed — a test in this chunk is likely leaking ` +
-            `an open handle (un-terminated Worker, un-killed child process, or ref'd timer) ` +
-            `so node --test never exits. Files: ${chunks[i]
-              .map(f => f.split(/[\\/]/).pop())
-              .join(' ')}`,
-        );
-      }
-      const code = err.status || 1;
-      // Run every chunk so the operator sees all failures in one pass; report
-      // the first non-zero exit at the end.
-      if (firstFailureExit === 0) firstFailureExit = code;
+    } else if (result.error) {
+      console.error(`run-tests: chunk ${i + 1}/${chunks.length} could not run: ${result.error.message}`);
+      code = 1;
+    } else if (code === 0 && !hasTestSummary(result.stdout)) {
+      console.error(
+        `run-tests: chunk ${i + 1}/${chunks.length} exited without a test summary ` +
+          `(no "ℹ tests N" / "ℹ fail N" lines) — its output was cut off, so some of its ` +
+          `tests never reported. Files: ${chunkFiles}`,
+      );
+      code = 1;
     }
+    // Run every chunk so the operator sees all failures in one pass; report
+    // the first non-zero exit at the end.
+    if (code !== 0 && firstFailureExit === 0) firstFailureExit = code;
   }
   if (firstFailureExit !== 0) return firstFailureExit;
 }
 
+/**
+ * Whether a chunk's stdout carries node:test's closing summary: both the
+ * `tests N` and `fail N` lines, from the spec reporter (`ℹ`) or TAP (`#`).
+ */
+function hasTestSummary(stdout) {
+  const text = stdout ? stdout.toString('utf8') : '';
+  return /^(?:ℹ|#) tests \d+\s*$/m.test(text) && /^(?:ℹ|#) fail \d+\s*$/m.test(text);
+}
+
 if (require.main === module) {
   runMain(main);
 }
 
-module.exports = { suiteOf, ensureBuiltArtifacts, parseShardArg, selectShard };
+module.exports = { suiteOf, ensureBuiltArtifacts, parseShardArg, selectShard, hasTestSummary };