monomind 1.9.0 → 1.9.1

package/package.json

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

@@ -959,19 +959,28 @@ async function copySkills(targetDir, options, result) {
         result.errors.push('Could not find source skills directory');
         return;
     }
-    // Copy each skill
-    for (const skillName of [...new Set(skillsToCopy)]) {
+    // Remove stale skill directories no longer in the current version's map
+    const knownSkills = new Set([...new Set(skillsToCopy)]);
+    if (fs.existsSync(targetSkillsDir)) {
+        for (const existing of fs.readdirSync(targetSkillsDir)) {
+            if (!knownSkills.has(existing)) {
+                const stalePath = path.join(targetSkillsDir, existing);
+                fs.rmSync(stalePath, { recursive: true, force: true });
+                result.created.files.push(`[cleaned] .claude/skills/${existing} (stale)`);
+            }
+        }
+    }
+    // Always copy/overwrite skills (never skip — ensures new version content lands)
+    for (const skillName of knownSkills) {
         const sourcePath = path.join(sourceSkillsDir, skillName);
         const targetPath = path.join(targetSkillsDir, skillName);
         if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                copyDirRecursive(sourcePath, targetPath);
-                result.created.files.push(`.claude/skills/${skillName}`);
-                result.summary.skillsCount++;
-            }
-            else {
-                result.skipped.push(`.claude/skills/${skillName}`);
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
             }
+            copyDirRecursive(sourcePath, targetPath);
+            result.created.files.push(`.claude/skills/${skillName}`);
+            result.summary.skillsCount++;
         }
     }
 }
@@ -1038,24 +1047,33 @@ async function copyCommands(targetDir, options, result) {
         result.errors.push('Could not find source commands directory');
         return;
     }
-    // Copy each command/directory
-    for (const cmdName of [...new Set(commandsToCopy)]) {
+    // Remove stale command files/directories no longer in the current version's map
+    const knownCommands = new Set([...new Set(commandsToCopy)]);
+    if (fs.existsSync(targetCommandsDir)) {
+        for (const existing of fs.readdirSync(targetCommandsDir)) {
+            if (!knownCommands.has(existing)) {
+                const stalePath = path.join(targetCommandsDir, existing);
+                fs.rmSync(stalePath, { recursive: true, force: true });
+                result.created.files.push(`[cleaned] .claude/commands/${existing} (stale)`);
+            }
+        }
+    }
+    // Always copy/overwrite commands (never skip — ensures new version content lands)
+    for (const cmdName of knownCommands) {
         const sourcePath = path.join(sourceCommandsDir, cmdName);
         const targetPath = path.join(targetCommandsDir, cmdName);
         if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                if (fs.statSync(sourcePath).isDirectory()) {
-                    copyDirRecursive(sourcePath, targetPath);
-                }
-                else {
-                    fs.copyFileSync(sourcePath, targetPath);
-                }
-                result.created.files.push(`.claude/commands/${cmdName}`);
-                result.summary.commandsCount++;
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+            }
+            if (fs.statSync(sourcePath).isDirectory()) {
+                copyDirRecursive(sourcePath, targetPath);
             }
             else {
-                result.skipped.push(`.claude/commands/${cmdName}`);
+                fs.copyFileSync(sourcePath, targetPath);
             }
+            result.created.files.push(`.claude/commands/${cmdName}`);
+            result.summary.commandsCount++;
         }
     }
 }
@@ -1094,21 +1112,30 @@ async function copyAgents(targetDir, options, result) {
         result.errors.push('Could not find source agents directory');
         return;
     }
-    // Copy each agent category
-    for (const agentCategory of [...new Set(agentsToCopy)]) {
+    // Remove stale agent category directories no longer in the current version's map
+    const knownAgents = new Set([...new Set(agentsToCopy)]);
+    if (fs.existsSync(targetAgentsDir)) {
+        for (const existing of fs.readdirSync(targetAgentsDir)) {
+            if (!knownAgents.has(existing)) {
+                const stalePath = path.join(targetAgentsDir, existing);
+                fs.rmSync(stalePath, { recursive: true, force: true });
+                result.created.files.push(`[cleaned] .claude/agents/${existing} (stale)`);
+            }
+        }
+    }
+    // Always copy/overwrite agents (never skip — ensures new version content lands)
+    for (const agentCategory of knownAgents) {
         const sourcePath = path.join(sourceAgentsDir, agentCategory);
         const targetPath = path.join(targetAgentsDir, agentCategory);
         if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                copyDirRecursive(sourcePath, targetPath);
-                // Count agent files (.md only — .yaml agents were migrated to .md)
-                const mdFiles = countFiles(sourcePath, '.md');
-                result.summary.agentsCount += mdFiles;
-                result.created.files.push(`.claude/agents/${agentCategory}`);
-            }
-            else {
-                result.skipped.push(`.claude/agents/${agentCategory}`);
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
             }
+            copyDirRecursive(sourcePath, targetPath);
+            // Count agent files (.md only — .yaml agents were migrated to .md)
+            const mdFiles = countFiles(sourcePath, '.md');
+            result.summary.agentsCount += mdFiles;
+            result.created.files.push(`.claude/agents/${agentCategory}`);
         }
     }
 }

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

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