monomind 1.10.45 → 1.10.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.45",
+  "version": "1.10.47",
   "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/init.js

@@ -34,7 +34,8 @@ const initAction = async (ctx) => {
         if (initialized.monomind)
             output.printInfo('  Found: .monomind/config.yaml');
         output.printInfo('Use --force to reinitialize');
-        if (ctx.interactive) {
+        const yes = ctx.flags.yes || process.env.CI === 'true';
+        if (ctx.interactive && !yes) {
             const proceed = await confirm({
                 message: 'Do you want to reinitialize? This will overwrite existing configuration.',
                 default: false,
@@ -43,8 +44,8 @@ const initAction = async (ctx) => {
                 return { success: true, message: 'Initialization cancelled' };
             }
         }
-        else {
-            return { success: false, exitCode: 1, message: 'Already initialized' };
+        else if (!yes) {
+            return { success: false, exitCode: 1, message: 'Already initialized. Use --force or --yes to reinitialize.' };
         }
     }
     output.writeln();
@@ -849,6 +850,13 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'yes',
+            short: 'y',
+            description: 'Skip confirmation prompts (also honoured via CI=true env var)',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'minimal',
             short: 'm',

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -640,12 +640,14 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 fs.mkdirSync(fullPath, { recursive: true });
             }
         }
-        // 0. ALWAYS update critical helpers (force overwrite)
+        // 0. ALWAYS update critical helpers + subdirectories (force overwrite)
         const sourceHelpersForUpgrade = findSourceHelpersDir();
         if (sourceHelpersForUpgrade) {
+            const destHelpersDir = path.join(targetDir, '.claude', 'helpers');
+            // Copy top-level critical files atomically
             const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
             for (const helperName of criticalHelpers) {
-                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                const targetPath = path.join(destHelpersDir, helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
                 if (fs.existsSync(sourcePath)) {
                     if (fs.existsSync(targetPath)) {
@@ -654,18 +656,24 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                     else {
                         result.created.push(`.claude/helpers/${helperName}`);
                     }
-                    // Atomic copy-via-rename: a SIGINT/crash during copy would leave a
-                    // half-written hook-handler.cjs which Claude Code executes on every
-                    // hook event — partial JS could disable security checks silently.
-                    {
-                        const tmp = targetPath + '.tmp';
-                        fs.copyFileSync(sourcePath, tmp);
-                        try {
-                            fs.chmodSync(tmp, 0o755);
-                        }
-                        catch { }
-                        fs.renameSync(tmp, targetPath);
+                    // Atomic copy-via-rename so a partial write can't leave a broken hook
+                    const tmp = targetPath + '.tmp';
+                    fs.copyFileSync(sourcePath, tmp);
+                    try {
+                        fs.chmodSync(tmp, 0o755);
                     }
+                    catch { }
+                    fs.renameSync(tmp, targetPath);
+                }
+            }
+            // Always recursively sync subdirectories (utils/, handlers/) — required by hook-handler.cjs.
+            // Uses recursive copy so any future nested subdirs are also covered.
+            for (const subdir of ['utils', 'handlers']) {
+                const srcSubdir = path.join(sourceHelpersForUpgrade, subdir);
+                const destSubdir = path.join(destHelpersDir, subdir);
+                if (fs.existsSync(srcSubdir)) {
+                    copyDirRecursive(srcSubdir, destSubdir);
+                    result.updated.push(`.claude/helpers/${subdir}/`);
                 }
             }
         }
@@ -1210,12 +1218,19 @@ async function copyAgents(targetDir, options, result) {
 }
 /**
  * Find source helpers directory.
- * Validates that the directory contains hook-handler.cjs to avoid
- * returning the target directory or an incomplete source.
+ * Validates that the directory contains hook-handler.cjs AND its required
+ * subdirectory files (utils/telemetry.cjs etc.) to avoid accepting a partial
+ * or corrupted source that would reproduce the missing-utils/ bug class.
  */
 function findSourceHelpersDir(sourceBaseDir) {
     const possiblePaths = [];
-    const SENTINEL_FILE = 'hook-handler.cjs'; // Must exist in valid source
+    // All sentinel files must exist — hook-handler.cjs requires these at startup
+    const SENTINEL_FILES = [
+        'hook-handler.cjs',
+        path.join('utils', 'telemetry.cjs'),
+        path.join('utils', 'monograph.cjs'),
+        path.join('utils', 'micro-agents.cjs'),
+    ];
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
         possiblePaths.push(path.join(sourceBaseDir, '.claude', 'helpers'));
@@ -1251,9 +1266,9 @@ function findSourceHelpersDir(sourceBaseDir) {
         path.join(process.cwd(), '..', '..', '.claude', 'helpers'),
     ];
     possiblePaths.push(...cwdBased);
-    // Return first path that exists AND contains the sentinel file
+    // Return first path that exists AND contains ALL sentinel files
     for (const p of possiblePaths) {
-        if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
+        if (fs.existsSync(p) && SENTINEL_FILES.every(f => fs.existsSync(path.join(p, f)))) {
             return p;
         }
     }
@@ -1266,29 +1281,34 @@ async function writeHelpers(targetDir, options, result) {
     const helpersDir = path.join(targetDir, '.claude', 'helpers');
     // Find source helpers directory (works for npm package and local dev)
     const sourceHelpersDir = findSourceHelpersDir(options.sourceBaseDir);
-    // Try to copy existing helpers from source first
+    // Try to copy existing helpers from source first (recursive — includes utils/ and handlers/)
     if (sourceHelpersDir && fs.existsSync(sourceHelpersDir)) {
-        const helperFiles = fs.readdirSync(sourceHelpersDir);
         let copiedCount = 0;
-        for (const file of helperFiles) {
-            const sourcePath = path.join(sourceHelpersDir, file);
-            const destPath = path.join(helpersDir, file);
-            // Skip directories and only copy files
-            if (!fs.statSync(sourcePath).isFile())
-                continue;
-            if (!fs.existsSync(destPath) || options.force) {
-                fs.copyFileSync(sourcePath, destPath);
-                // Make shell scripts and mjs files executable
-                if (file.endsWith('.sh') || file.endsWith('.mjs')) {
-                    fs.chmodSync(destPath, '755');
+        const copyRecursive = (srcDir, destDir, relBase) => {
+            fs.mkdirSync(destDir, { recursive: true });
+            for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+                const srcPath = path.join(srcDir, entry.name);
+                const destPath = path.join(destDir, entry.name);
+                const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    copyRecursive(srcPath, destPath, relPath);
+                }
+                else {
+                    if (!fs.existsSync(destPath) || options.force) {
+                        fs.copyFileSync(srcPath, destPath);
+                        if (entry.name.endsWith('.sh') || entry.name.endsWith('.mjs')) {
+                            fs.chmodSync(destPath, '755');
+                        }
+                        result.created.files.push(`.claude/helpers/${relPath}`);
+                        copiedCount++;
+                    }
+                    else {
+                        result.skipped.push(`.claude/helpers/${relPath}`);
+                    }
                 }
-                result.created.files.push(`.claude/helpers/${file}`);
-                copiedCount++;
-            }
-            else {
-                result.skipped.push(`.claude/helpers/${file}`);
             }
-        }
+        };
+        copyRecursive(sourceHelpersDir, helpersDir, '');
         if (copiedCount > 0) {
             return; // Skip generating if we copied from source
         }
@@ -1297,9 +1317,9 @@ async function writeHelpers(targetDir, options, result) {
     const helpers = {
         'pre-commit': generatePreCommitHook(),
         'post-commit': generatePostCommitHook(),
-        'session.js': generateSessionManager(),
-        'router.js': generateAgentRouter(),
-        'memory.js': generateMemoryHelper(),
+        'session.cjs': generateSessionManager(),
+        'router.cjs': generateAgentRouter(),
+        'memory.cjs': generateMemoryHelper(),
         'hook-handler.cjs': generateHookHandler(),
         'intelligence.cjs': generateIntelligenceStub(),
         'auto-memory-hook.mjs': generateAutoMemoryHook(),

package/packages/@monomind/cli/dist/src/init/helpers-generator.js

@@ -401,9 +401,9 @@ export function generateHookHandler() {
         '  return null;',
         '}',
         '',
-        "const router = safeRequire(path.join(helpersDir, 'router.js'));",
-        "const session = safeRequire(path.join(helpersDir, 'session.js'));",
-        "const memory = safeRequire(path.join(helpersDir, 'memory.js'));",
+        "const router = safeRequire(path.join(helpersDir, 'router.cjs'));",
+        "const session = safeRequire(path.join(helpersDir, 'session.cjs'));",
+        "const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));",
         "const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));",
         '',
         'const [,, command, ...args] = process.argv;',

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.45",
+  "version": "1.10.47",
   "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",