monomind 1.10.21 → 1.10.22

package/.claude/helpers/hook-handler.cjs

@@ -1470,6 +1470,60 @@ const handlers = {
         console.log('[OK] Session restored: session-' + Date.now());
       }
     } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
+
+    // Stale helper detection — compare local helper hashes against the
+    // bundled (npm-installed) monomind copy and warn if they drift. This
+    // is what alerts the user that 'monomind init upgrade' would pick up
+    // new features (graph fallback routing, telemetry counters, etc).
+    try {
+      var crypto = require('crypto');
+      // Walk up from this file to find the monomind package root (looks for
+      // package.json with name === 'monomind' or '@monomind/cli').
+      function _findBundledHelpers() {
+        var helperPaths = [
+          path.join(__dirname),
+          path.join(CWD, 'node_modules', 'monomind', '.claude', 'helpers'),
+          path.join(CWD, 'node_modules', '@monoes', 'monomindcli', '.claude', 'helpers'),
+        ];
+        try {
+          var globalRoot = require('child_process')
+            .execSync('npm root -g 2>/dev/null', { encoding: 'utf-8', timeout: 2000 })
+            .trim();
+          if (globalRoot) {
+            helperPaths.push(path.join(globalRoot, 'monomind', '.claude', 'helpers'));
+            helperPaths.push(path.join(globalRoot, '@monoes', 'monomindcli', '.claude', 'helpers'));
+          }
+        } catch (_) {}
+        for (var i = 0; i < helperPaths.length; i++) {
+          if (fs.existsSync(path.join(helperPaths[i], 'hook-handler.cjs')) &&
+              helperPaths[i] !== path.join(CWD, '.claude', 'helpers')) {
+            return helperPaths[i];
+          }
+        }
+        return null;
+      }
+
+      var bundledDir = _findBundledHelpers();
+      if (bundledDir) {
+        var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs'];
+        var stale = [];
+        for (var hi = 0; hi < helpersToCheck.length; hi++) {
+          var hName = helpersToCheck[hi];
+          var localF   = path.join(CWD, '.claude', 'helpers', hName);
+          var bundledF = path.join(bundledDir, hName);
+          if (!fs.existsSync(localF) || !fs.existsSync(bundledF)) continue;
+          try {
+            var hashL = crypto.createHash('sha256').update(fs.readFileSync(localF)).digest('hex');
+            var hashB = crypto.createHash('sha256').update(fs.readFileSync(bundledF)).digest('hex');
+            if (hashL !== hashB) stale.push(hName);
+          } catch (_) {}
+        }
+        if (stale.length > 0) {
+          console.log('[STALE_HELPERS] Project helpers differ from bundled version: ' + stale.join(', '));
+          console.log('  Run `npx monomind@latest init upgrade` to refresh and pick up the latest features.');
+        }
+      }
+    } catch (e) { /* non-fatal */ }
     // Initialize intelligence (with timeout — #1530)
     // Respects monomind.neural.enabled kill switch from settings.json
     var neuralEnabled = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.21",
+  "version": "1.10.22",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/commands/doctor.js

@@ -411,6 +411,86 @@ async function checkMonograph() {
     }
 }
 // Check agentic-flow v1 integration (filesystem-based to avoid slow WASM/DB init)
+// Resolve the path to the bundled (npm-installed) copy of a helper file.
+// Walks up from this module's location to find the package root, then joins
+// the relative path. Returns null if not found.
+function _resolveBundledHelper(relativePath) {
+    try {
+        const thisFile = fileURLToPath(import.meta.url);
+        let dir = dirname(thisFile);
+        for (;;) {
+            const candidate = join(dir, 'package.json');
+            if (existsSync(candidate)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                    if (pkg.name === '@monomind/cli' || pkg.name === 'monomind') {
+                        const helperPath = join(dir, relativePath);
+                        return existsSync(helperPath) ? helperPath : null;
+                    }
+                }
+                catch { /* keep walking */ }
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                return null;
+            dir = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+// Compare per-project helper file content vs the bundled (npm) version.
+// Returns the list of files that drifted.
+async function _detectStaleHelpers() {
+    const stale = [];
+    const missing = [];
+    const helpers = ['hook-handler.cjs', 'statusline.cjs', 'router.cjs', 'graphify-freshen.cjs'];
+    const crypto = await import('node:crypto');
+    for (const name of helpers) {
+        const local = join(process.cwd(), '.claude', 'helpers', name);
+        if (!existsSync(local))
+            continue;
+        const bundled = _resolveBundledHelper(join('.claude', 'helpers', name));
+        if (!bundled) {
+            missing.push(name);
+            continue;
+        }
+        try {
+            const hashLocal = crypto.createHash('sha256').update(readFileSync(local)).digest('hex');
+            const hashBundled = crypto.createHash('sha256').update(readFileSync(bundled)).digest('hex');
+            if (hashLocal !== hashBundled)
+                stale.push(name);
+        }
+        catch { /* skip */ }
+    }
+    return { stale, missing };
+}
+async function checkHelpersFresh() {
+    try {
+        const { stale, missing } = await _detectStaleHelpers();
+        if (stale.length === 0 && missing.length === 0) {
+            return { name: 'Helper Files', status: 'pass', message: 'Project helpers match bundled version' };
+        }
+        if (stale.length > 0) {
+            return {
+                name: 'Helper Files',
+                status: 'warn',
+                message: `${stale.length} stale helper(s) in .claude/helpers/: ${stale.join(', ')}`,
+                fix: 'monomind init upgrade',
+            };
+        }
+        return {
+            name: 'Helper Files',
+            status: 'warn',
+            message: `Could not locate bundled copies of: ${missing.join(', ')}`,
+            fix: 'Reinstall monomind or run `monomind init upgrade`',
+        };
+    }
+    catch (e) {
+        return { name: 'Helper Files', status: 'warn', message: `check failed: ${e instanceof Error ? e.message : 'unknown'}` };
+    }
+}
 async function checkAgenticFlow() {
     try {
         // Walk common node_modules paths to find agentic-flow/package.json
@@ -523,6 +603,7 @@ export const doctorCommand = {
             checkDiskSpace,
             checkBuildTools,
             checkMonograph,
+            checkHelpersFresh,
             checkAgenticFlow
         ];
         const componentMap = {
@@ -540,6 +621,7 @@ export const doctorCommand = {
             'disk': checkDiskSpace,
             'typescript': checkBuildTools,
             'monograph': checkMonograph,
+            'helpers': checkHelpersFresh,
             'agentic-flow': checkAgenticFlow
         };
         let checksToRun = allChecks;

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.21",
+  "version": "1.10.22",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",