@pareto4/pp-core 1.13.0 → 1.18.0

package/pp-core/bin/lib/capability-activation.cjs

@@ -13,11 +13,19 @@ const node_path_1 = __importDefault(require("node:path"));
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const planningWorkspaceMod = require("./planning-workspace.cjs");
 const { planningDir, planningRoot } = planningWorkspaceMod;
+/**
+ * Segments that must never be walked or matched, on either key form.
+ * Extracted so the nested walk and the flat fallback cannot drift into
+ * disagreeing about what a pollution attempt looks like.
+ */
+function _isRejectedKeySegment(seg) {
+    return seg === '__proto__' || seg === 'constructor' || seg === 'prototype';
+}
 function _getNestedConfigValue(config, dotKey) {
     const segments = dotKey.split('.');
     let current = config;
     for (const seg of segments) {
-        if (seg === '__proto__' || seg === 'constructor' || seg === 'prototype') {
+        if (_isRejectedKeySegment(seg)) {
             return { found: false, value: undefined };
         }
         if (typeof current !== 'object' || current === null) {
@@ -31,6 +39,65 @@ function _getNestedConfigValue(config, dotKey) {
     }
     return { found: true, value: current };
 }
+/**
+ * GATE-05: look the WHOLE dotted string up as a single own property.
+ *
+ * An operator hand-pasting a gate key into a config.json they did not write
+ * writes `{"vault.required": true}` at least as often as the three-line nested
+ * form. Before this existed, that flat shape resolved nowhere — the nested walk
+ * looked up `config['vault']`, found nothing, and the key silently fell through
+ * to its default. For an enforcement gate that is a fail-open with no error
+ * message, which is exactly the failure GATE-05 exists to close.
+ *
+ * Performs NO traversal: one own-property check on a string already in hand.
+ * The rejected-segment guard is applied to every segment of the dotted string
+ * anyway (T-02-13) so the flat path can never become the bypass the nested
+ * path already closes, and `hasOwnProperty` is required (T-02-14) so an
+ * inherited property is never mistaken for configuration.
+ *
+ * A flat own property valued `undefined` is reported NOT-found on purpose: it
+ * cannot come from JSON, and treating it as configured would let a
+ * programmatically built object shadow the schema default with nothing.
+ */
+function _getFlatConfigValue(config, dotKey) {
+    for (const seg of dotKey.split('.')) {
+        if (_isRejectedKeySegment(seg))
+            return { found: false, value: undefined };
+    }
+    if (typeof config !== 'object' || config === null) {
+        return { found: false, value: undefined };
+    }
+    if (!Object.prototype.hasOwnProperty.call(config, dotKey)) {
+        return { found: false, value: undefined };
+    }
+    const value = config[dotKey];
+    if (value === undefined)
+        return { found: false, value: undefined };
+    return { found: true, value };
+}
+/**
+ * GATE-05: resolve a dotted key in EITHER form against one config object.
+ *
+ * PRECEDENCE — nested first, flat only as a fallback. This ordering is the
+ * decision, not an implementation detail: when both forms are present for the
+ * same key the NESTED form wins. Chosen because every shipped example and every
+ * project configured to date is nested, so a nested-first fallback cannot move
+ * the resolution of any key that resolves today — the flat form resolves
+ * nowhere at present, so adding it below the nested walk is strictly additive.
+ * A flat-first ordering would silently change behaviour for any project that
+ * later adds a flat key alongside a nested one. Pinned by the
+ * "both forms present … NESTED wins" tests in
+ * tests/capability-precedence-parity.test.cjs; invert this and they go red.
+ *
+ * Called from the leaf of every precedence level, so levels 1-3 inherit the
+ * fallback without any change to the four-level walk itself.
+ */
+function getConfigValueEitherForm(config, dotKey) {
+    const nested = _getNestedConfigValue(config, dotKey);
+    if (nested.found)
+        return nested;
+    return _getFlatConfigValue(config, dotKey);
+}
 const _warnedRawConfigPaths = new Set();
 function _readRawConfigKey(filePath, dotKey) {
     try {
@@ -49,7 +116,9 @@ function _readRawConfigKey(filePath, dotKey) {
             }
             return { found: false, value: undefined };
         }
-        return _getNestedConfigValue(parsed, dotKey);
+        // GATE-05: levels 2 and 3 read raw config.json files — the surface an
+        // operator hand-edits — so they need both key forms, nested first.
+        return getConfigValueEitherForm(parsed, dotKey);
     }
     catch {
         return { found: false, value: undefined };
@@ -58,11 +127,11 @@ function _readRawConfigKey(filePath, dotKey) {
 /**
  * The raw config files levels 2 and 3 read, in read order: the active
  * `planningDir(cwd)/config.json`, then the root `planningRoot(cwd)/config.json`
- * when it is a different file. Exported so `unreadableConfigFiles`
- * (src/config-loader.cts) parses every file the hook resolver reads — this list
- * beside `configFilesFor`, the loader's — without restating either. Both levels
- * skip an unparseable file with a stderr warning and read on, which is the
- * swallow a gate-governing caller must refuse.
+ * when it is a different file (16-04, D-28). Exported so the door-admission
+ * verdict (`vaultAdmissionVerdict` in src/vault.cts) parses every file the gate
+ * reads — this list beside `configFilesFor`, the loader's — without restating
+ * either. Both levels skip an unparseable file with a stderr warning and read
+ * on, which is the swallow the verdict exists to refuse.
  */
 function activationConfigFilesFor(cwd) {
     const wsConfigPath = node_path_1.default.join(planningDir(cwd), 'config.json');
@@ -84,8 +153,8 @@ function activationConfigFilesFor(cwd) {
  */
 function resolveConfigKey(dotKey, opts) {
     const { config, cwd, registry } = opts;
-    // Level 1: loadConfig result
-    const fromConfig = _getNestedConfigValue(config, dotKey);
+    // Level 1: loadConfig result (GATE-05: nested form first, flat form as fallback)
+    const fromConfig = getConfigValueEitherForm(config, dotKey);
     if (fromConfig.found)
         return { found: true, value: fromConfig.value };
     // Level 2 + 3: raw config.json files (only when cwd is available)
@@ -116,6 +185,11 @@ function _resolveActivationValue(dotKey, config, cwd, registry) {
 }
 module.exports = {
     _getNestedConfigValue,
+    // GATE-05: exported so src/config.cts's cmdConfigGet reuses this exact flat
+    // lookup rather than growing a second, driftable copy of the rule.
+    _getFlatConfigValue,
+    _isRejectedKeySegment,
+    getConfigValueEitherForm,
     _readRawConfigKey,
     _resolveActivationValue,
     resolveConfigKey,