@mutmutco/cursor-plugin 4.1.1 → 4.1.3

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mmi",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "mmiCompat": "4.x",
   "description": "MMI workflow skills and organisation gates for Cursor.",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cursor-plugin",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "MMI workflow skills and organisation gates for Cursor.",
   "author": {
     "name": "MMI Future",

package/scripts/pretooluse-shell-gates.mjs

@@ -11,6 +11,7 @@ import { decide as decideCommandLadder, matchedVerb } from './command-ladder-gat
 import { handleGateCrash, handleMissingHookInput, recordGateSuccess } from './deny-gate-crash.mjs';
 import { readHookInput } from './hook-io.mjs';
 import { appendHookActivity } from './hook-trace.mjs';
+import { evaluateTestCommandPolicy } from './test-command-policy-core.mjs';
 
 // Secret echoes are blocked before execution on every active host.
 const SECRET_ECHO_MODE = process.env.MMI_SECRET_ECHO_LINT || 'block';
@@ -358,34 +359,14 @@ function repositoryRoot(input) {
   return null;
 }
 
-function policyMandatoryGlobs(root) {
+function policyMandatoryEntries(root) {
   const path = resolve(root, 'test-policy.json');
   if (!existsSync(path)) return null;
   const parsed = JSON.parse(readFileSync(path, 'utf8'));
   if (!Array.isArray(parsed.mandatory) || !parsed.mandatory.every((entry) => entry && typeof entry.glob === 'string')) {
     throw new Error('test-policy.json mandatory entries are invalid');
   }
-  return parsed.mandatory.map((entry) => entry.glob);
-}
-
-function policyGlobToRegExp(glob) {
-  let out = '';
-  for (let i = 0; i < glob.length; i += 1) {
-    const char = glob[i];
-    if (char === '*') {
-      if (glob[i + 1] === '*') {
-        if (glob[i + 2] === '/') { out += '(?:.*/)?'; i += 2; } else { out += '.*'; i += 1; }
-      } else out += '[^/]*';
-    } else if (char === '{') {
-      const close = glob.indexOf('}', i);
-      if (close === -1) out += '\\{';
-      else {
-        out += `(?:${glob.slice(i + 1, close).split(',').map(policyGlobToRegExp).join('|')})`;
-        i = close;
-      }
-    } else out += /[.+?^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
-  }
-  return out;
+  return parsed.mandatory;
 }
 
 function taskDiffPaths(root) {
@@ -410,12 +391,18 @@ function taskDiffPaths(root) {
 function runTestCommandPolicy(input, { stdout = process.stdout } = {}) {
   if (!requestedTestCommand(input?.tool_input?.command)) return { denied: false };
   const root = repositoryRoot(input);
-  let globs;
+  let mandatory;
   try {
     // No declaration is the estate default: this hook does not regulate test execution there.
-    if (!root || (globs = policyMandatoryGlobs(root)) === null) return { denied: false };
-    const paths = taskDiffPaths(root);
-    if (paths.some((path) => globs.some((glob) => new RegExp(`^${policyGlobToRegExp(glob)}$`).test(path)))) return { denied: false };
+    if (!root || (mandatory = policyMandatoryEntries(root)) === null) return { denied: false };
+    // #5519: same evaluator `mmi-cli tests policy` attaches to its OK summary — matched globs and
+    // command classes cannot disagree with the CLI on the same path set.
+    const decision = evaluateTestCommandPolicy({
+      paths: taskDiffPaths(root),
+      mandatory,
+      regulated: true,
+    });
+    if (decision.testCommandsAllowed) return { denied: false, decision };
   } catch (error) {
     const reason = 'TEST-POLICY TEST COMMAND REFUSED [test-command-policy-unresolvable]: '
       + `a test-policy.json applies but its repository, policy, or task diff could not be established (${error.message}). `

package/scripts/test-command-policy-core.mjs

@@ -0,0 +1,100 @@
+// test-command-policy-core.mjs — shared verdict for "may this diff run tests?" (#5519).
+//
+// `mmi-cli tests policy` and the PreToolUse test-command gate both answer that question. Before
+// #5519 they answered it separately: the CLI summary printed the repository's CONFIGURED mandatory
+// glob count on an OK line, while the gate independently matched the task diff against those globs
+// and refused a focused test when none hit. Agents read "8 mandatory glob(s)" as permission, then
+// hit TEST-POLICY TEST COMMAND REFUSED on the next line. Delegated workers and the parent hook also
+// diverged when they did not share an evaluator.
+//
+// This module is the one evaluator. It reports matched globs separately from configured totals and
+// the exact allowed/refused command classes. Pure: no IO, no git.
+
+/** Command class the PreToolUse gate regulates. Non-test verification is never refused here. */
+export const TEST_COMMAND_CLASS = 'test';
+
+/**
+ * Glob body → regex body. Supports `**`, `*`, and `{a,b}` (including wildcards inside braces).
+ * Kept byte-compatible with {@link globToRegExp} in cli/src/test-policy-core.ts so rule matching
+ * and the command guard cannot drift on the same policy file.
+ */
+export function translateGlob(glob) {
+  let out = '';
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === '*') {
+      if (glob[i + 1] === '*') {
+        if (glob[i + 2] === '/') {
+          out += '(?:.*/)?';
+          i += 2;
+        } else {
+          out += '.*';
+          i += 1;
+        }
+      } else out += '[^/]*';
+    } else if (char === '{') {
+      const close = glob.indexOf('}', i);
+      if (close === -1) out += '\\{';
+      else {
+        out += `(?:${glob.slice(i + 1, close).split(',').map(translateGlob).join('|')})`;
+        i = close;
+      }
+    } else {
+      out += /[.+?^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+    }
+  }
+  return out;
+}
+
+export function globToRegExp(glob) {
+  return new RegExp(`^${translateGlob(glob)}$`);
+}
+
+function mandatoryGlobList(mandatory) {
+  if (!Array.isArray(mandatory)) return [];
+  return mandatory.map((entry) => (typeof entry === 'string' ? entry : entry?.glob)).filter((glob) => typeof glob === 'string');
+}
+
+/** Mandatory globs that match at least one path in `paths`. Order follows the policy declaration. */
+export function matchedMandatoryGlobs(paths, mandatory) {
+  const globs = mandatoryGlobList(mandatory);
+  const list = Array.isArray(paths) ? paths : [];
+  return globs.filter((glob) => {
+    const re = globToRegExp(glob);
+    return list.some((path) => re.test(path));
+  });
+}
+
+/**
+ * Decide whether test commands are allowed against a path set and a mandatory zone.
+ *
+ * @param {{ paths: string[], mandatory?: unknown, regulated?: boolean }} input
+ *   `regulated: false` — no test-policy.json (estate default); tests are not gated.
+ *   `regulated: true` (default) — a declared policy applies; zero matched globs refuses `test`.
+ */
+export function evaluateTestCommandPolicy({ paths, mandatory, regulated = true } = {}) {
+  const configuredMandatoryCount = mandatoryGlobList(mandatory).length;
+  if (!regulated) {
+    return {
+      configuredMandatoryCount: 0,
+      matchedMandatoryGlobs: [],
+      matchedMandatoryCount: 0,
+      testCommandsAllowed: true,
+      reasonId: null,
+      commandClasses: { allowed: [TEST_COMMAND_CLASS], refused: [] },
+    };
+  }
+  const matched = matchedMandatoryGlobs(paths, mandatory);
+  const testCommandsAllowed = matched.length > 0;
+  return {
+    configuredMandatoryCount,
+    matchedMandatoryGlobs: matched,
+    matchedMandatoryCount: matched.length,
+    testCommandsAllowed,
+    reasonId: testCommandsAllowed ? null : 'test-command-outside-mandatory-zone',
+    commandClasses: {
+      allowed: testCommandsAllowed ? [TEST_COMMAND_CLASS] : [],
+      refused: testCommandsAllowed ? [] : [TEST_COMMAND_CLASS],
+    },
+  };
+}