@north-light/crouter 0.3.245 → 0.3.247

package/dist/commands/sys/context/resolve.js

@@ -248,7 +248,7 @@ export function entryText(entry) {
  *  its checks — the first failing one is the answer an engineer acts on. */
 export function exclusionReason(record, subject) {
     if (!record.docGate.pass) {
-        return `document gate: ${gateReason(record.docGate.reason, explainRecordGate(record, 'doc', subject))}`;
+        return 'document gate';
     }
     if (record.shadowedBy !== null)
         return `shadowed by ${record.shadowedBy.scope}:${record.shadowedBy.path}`;

package/dist/core/substrate/gate-explain.js

@@ -208,8 +208,9 @@ function commaList(arg) {
 function shortPath(value) {
     return value.startsWith('/') ? tildify(value) : value;
 }
-// Regex reduction — every real `cwd` gate is an anchored literal path, and it
-// should read as the directory it means.
+// Regex reduction — every real `cwd` gate is an anchored literal path, whole or
+// followed by one alternation of the projects it covers, and it should read as
+// the directory or directories it means.
 const META = new Set(['\\', '^', '$', '.', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}']);
 /** The pattern as the thing it demands: an anchored literal path collapsed to
  *  the directory it names, else the longest literal run it insists on, else an
@@ -225,6 +226,9 @@ export function readableRegex(source) {
     const literal = unescapeLiteral(body);
     if (literal !== null && literal !== '')
         return shortPath(literal);
+    const branches = distributeAlternation(body);
+    if (branches !== null)
+        return branches.map((branch) => shortPath(branch)).join(' or ');
     const run = longestLiteralRun(source);
     return run === null ? 'a pattern' : `contains "${shortPath(run)}"`;
 }
@@ -249,6 +253,73 @@ function unescapeLiteral(source) {
     }
     return out;
 }
+/** The paths a literal prefix followed by ONE alternation group means: each
+ *  branch appended to the prefix, so the reader is handed directories they can
+ *  actually be in rather than the prefix they all share. Null when the body is
+ *  any other shape — a second group, text after the group, or a branch holding
+ *  a metacharacter outside the glob vocabulary. */
+function distributeAlternation(body) {
+    const open = body.indexOf('(');
+    if (open === -1 || !body.endsWith(')'))
+        return null;
+    const prefix = unescapeLiteral(body.slice(0, open));
+    if (prefix === null)
+        return null;
+    let inner = body.slice(open + 1, -1);
+    if (inner.startsWith('?:'))
+        inner = inner.slice(2);
+    // One group only: a nested group is a shape this reduction does not read.
+    if (inner.includes('(') || inner.includes(')'))
+        return null;
+    const branches = inner.split('|');
+    if (branches.length < 2)
+        return null;
+    const paths = [];
+    for (const branch of branches) {
+        const text = branchText(branch);
+        if (text === null)
+            return null;
+        paths.push(prefix + text);
+    }
+    return paths;
+}
+/** One branch as plain text, with a whole-segment wildcard rendered as the path
+ *  glob it means. The vocabulary is exactly `[^/]+` and `.*`; any other
+ *  metacharacter means the branch is not a path and the whole shape is
+ *  abandoned. */
+function branchText(branch) {
+    let out = '';
+    for (let i = 0; i < branch.length; i++) {
+        if (branch.startsWith('[^/]+', i)) {
+            out += '*';
+            i += 4;
+            continue;
+        }
+        if (branch.startsWith('[^\\/]+', i)) {
+            out += '*';
+            i += 5;
+            continue;
+        }
+        if (branch.startsWith('.*', i)) {
+            out += '*';
+            i += 1;
+            continue;
+        }
+        const ch = branch[i];
+        if (ch === '\\') {
+            const next = branch[i + 1];
+            if (next === undefined || (!META.has(next) && next !== '/' && next !== '-'))
+                return null;
+            out += next;
+            i++;
+            continue;
+        }
+        if (META.has(ch))
+            return null;
+        out += ch;
+    }
+    return out;
+}
 /** The longest stretch of characters EVERY string the pattern accepts contains,
  *  or null when it guarantees nothing longer than a single character. Only text
  *  outside every group and character class counts: a group may be alternated or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.245",
+  "version": "0.3.247",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.245",
+  "version": "0.3.247",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.245",
+      "version": "0.3.247",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {