@monoes/monomindcli 1.7.0 → 1.9.0

package/dist/src/init/executor.js

@@ -10,6 +10,26 @@ import { dirname } from 'path';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+/**
+ * Atomic write helper — writes to a sibling .tmp file then renames into place.
+ * SIGINT or crash during a partial write would otherwise corrupt user-critical
+ * files (.claude/settings.json, .mcp.json, helper scripts that Claude Code
+ * executes on every hook). Without atomicity a half-written settings.json or
+ * a zero-byte hook-handler.cjs disables Claude Code's protections silently.
+ */
+function atomicWriteFile(target, content, encoding) {
+    const tmp = `${target}.${process.pid}.tmp`;
+    if (encoding && typeof content === 'string') {
+        fs.writeFileSync(tmp, content, encoding);
+    }
+    else if (typeof content === 'string') {
+        fs.writeFileSync(tmp, content, 'utf-8');
+    }
+    else {
+        fs.writeFileSync(tmp, content);
+    }
+    fs.renameSync(tmp, target);
+}
 import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
 import { writeSharedInstructions } from './shared-instructions-generator.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
@@ -24,6 +44,7 @@ const SKILLS_MAP = {
     core: [
         'swarm-orchestration',
         'swarm-advanced',
+        'swarm-coordination',
         'sparc-methodology',
         'hooks-automation',
         'pair-programming',
@@ -31,8 +52,12 @@ const SKILLS_MAP = {
         'stream-chain',
         'skill-builder',
         'specialagent',
+        'mastermind',
+        'monodesign',
+        'monomotion',
+        'hive-mind-advanced',
     ],
-    browser: ['browser', 'agent-browser-testing'], // agent-browser integration
+    browser: ['agent-browser-testing'],
     agentdb: [
         'agentdb-advanced',
         'agentdb-learning',
@@ -49,16 +74,17 @@ const SKILLS_MAP = {
         'github-release-management',
         'github-workflow-automation',
     ],
-    v1: [
-        'v1-cli-modernization',
-        'v1-core-implementation',
-        'v1-ddd-architecture',
-        'v1-integration-deep',
-        'v1-mcp-optimization',
-        'v1-memory-unification',
-        'v1-performance-optimization',
-        'v1-security-overhaul',
-        'v1-swarm-coordination',
+    advanced: [
+        'agentic-integration',
+        'agentic-jujutsu',
+        'cli-modernization',
+        'core-implementation',
+        'ddd-architecture',
+        'mcp-optimization',
+        'memory-unification',
+        'performance-analysis',
+        'performance-optimization',
+        'security-hardening',
     ],
 };
 /**
@@ -66,47 +92,69 @@ const SKILLS_MAP = {
  */
 const COMMANDS_MAP = {
     core: [
-        'monomind-help.md', 'monomind-swarm.md', 'monomind-memory.md',
-        'monomind-do.md', 'monomind-idea.md', 'monomind-improve.md', 'monomind-createtask.md', 'monomind-repeat.md',
-        'mastermind.md', 'list-agents.md', 'use-agent.md',
-        'metrics.md', 'tokens.md', 'browse.md', 'sparc.md', 'ts.md',
+        'mastermind.md', 'tokens.md', 'browse.md', 'sparc.md', 'ts.md',
     ],
+    agents: ['agents'],
     analysis: ['analysis'],
     automation: ['automation'],
+    coordination: ['coordination'],
     github: ['github'],
+    hiveMind: ['hive-mind'],
     hooks: ['hooks'],
+    mastermind: ['mastermind'],
+    memory: ['memory'],
     monitoring: ['monitoring'],
+    monograph: ['monograph'],
+    monomind: ['monomind'],
     optimization: ['optimization'],
+    pair: ['pair'],
     sparc: ['sparc'],
+    streamChain: ['stream-chain'],
+    swarm: ['swarm'],
+    training: ['training'],
+    truth: ['truth'],
+    verify: ['verify'],
+    workflows: ['workflows'],
 };
 /**
  * Agents to copy based on configuration
  */
 const AGENTS_MAP = {
-    core: ['core'],
-    consensus: ['consensus'],
-    github: ['github'],
-    hiveMind: ['hive-mind'],
-    sparc: ['sparc'],
-    swarm: ['swarm'],
-    browser: ['browser'], // agent-browser integration
-    // V1-specific agents
-    v1: ['v1'],
-    optimization: ['optimization'],
-    templates: ['templates'],
-    testing: ['testing'],
-    sublinear: ['sublinear'],
+    academic: ['academic'],
     analysis: ['analysis'],
     architecture: ['architecture'],
+    consensus: ['consensus'],
+    core: ['core'],
+    data: ['data'],
+    design: ['design'],
     development: ['development'],
     devops: ['devops'],
     documentation: ['documentation'],
-    specialized: ['specialized'],
+    engineering: ['engineering'],
+    gameDevelopment: ['game-development'],
+    github: ['github'],
     goal: ['goal'],
-    sona: ['sona'],
+    hiveMind: ['hive-mind'],
+    marketing: ['marketing'],
+    neural: ['neural'],
+    optimization: ['optimization'],
+    paidMedia: ['paid-media'],
     payments: ['payments'],
-    data: ['data'],
-    custom: ['custom'],
+    product: ['product'],
+    projectManagement: ['project-management'],
+    reasoning: ['reasoning'],
+    sales: ['sales'],
+    schemas: ['schemas'],
+    sona: ['sona'],
+    sparc: ['sparc'],
+    spatialComputing: ['spatial-computing'],
+    specialists: ['specialists'],
+    specialized: ['specialized'],
+    sublinear: ['sublinear'],
+    support: ['support'],
+    swarm: ['swarm'],
+    templates: ['templates'],
+    testing: ['testing'],
 };
 /**
  * Directory structure to create
@@ -171,7 +219,7 @@ function cleanupLegacyTools(targetDir) {
                 cleaned.push('.mcp.json: updated MCP package name to monomind@latest');
             }
             if (mcpChanged) {
-                fs.writeFileSync(mcpJsonPath, JSON.stringify(mcp, null, 2));
+                atomicWriteFile(mcpJsonPath, JSON.stringify(mcp, null, 2));
             }
         }
         catch { /* non-fatal */ }
@@ -207,7 +255,7 @@ function cleanupLegacyTools(targetDir) {
                 cleaned.push('.claude/settings.json: updated MCP package name to monomind@latest');
             }
             if (settingsChanged) {
-                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+                atomicWriteFile(settingsPath, JSON.stringify(settings, null, 2));
             }
         }
         catch { /* non-fatal */ }
@@ -302,82 +350,25 @@ export async function executeInit(options) {
     return result;
 }
 /**
- * Ensure graphify (Python knowledge graph engine) is installed.
- * Tries uv first, falls back to pip. Non-fatal if neither works.
- */
-async function ensureGraphifyInstalled(result) {
-    const { execSync } = await import('child_process');
-    try {
-        execSync('graphify --help', { encoding: 'utf8', stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        const installers = ['uv tool install graphifyy', 'pip install graphifyy'];
-        for (const cmd of installers) {
-            try {
-                execSync(cmd, { encoding: 'utf8', stdio: 'ignore', timeout: 120000 });
-                result.created.files.push('graphify (installed via ' + cmd.split(' ')[0] + ')');
-                return true;
-            }
-            catch { /* try next */ }
-        }
-        result.skipped.push('graphify: could not auto-install (run: uv tool install graphifyy)');
-        return false;
-    }
-}
-/**
- * Initialize graphify fully: install skill, git hooks, build graph, install watch.
- * Fire-and-forget for the graph build — init does not wait for it to complete.
- * Non-fatal: if graphify is unavailable the step is simply skipped.
+ * Initialize the Monograph knowledge graph (native TypeScript, no Python required).
+ * Fire-and-forget build — init does not wait for it to complete.
  */
 async function initKnowledgeGraph(targetDir, result) {
-    const installed = await ensureGraphifyInstalled(result);
-    if (!installed)
-        return;
-    const { execSync, spawn } = await import('child_process');
     const { mkdirSync } = await import('fs');
     const outputDir = path.join(targetDir, '.monomind', 'graph');
     mkdirSync(outputDir, { recursive: true });
-    // 1. Install graphify skill into Claude Code config
-    try {
-        execSync('graphify claude install', { cwd: targetDir, stdio: 'ignore', timeout: 10000 });
-        result.created.files.push('graphify claude skill (installed)');
-    }
-    catch { /* non-fatal */ }
-    // 2. Install git hooks (auto-rebuild on commit)
-    try {
-        execSync('graphify hook install', { cwd: targetDir, stdio: 'ignore', timeout: 10000 });
-        result.created.files.push('graphify git hooks (post-commit, post-checkout)');
-    }
-    catch { /* non-fatal */ }
-    // 3. Build knowledge graph in background (fire-and-forget)
     try {
-        const child = spawn('graphify', ['update', targetDir], {
-            stdio: 'ignore',
-            detached: true,
-            cwd: targetDir,
+        const { buildAsync } = await import('@monoes/monograph');
+        buildAsync(targetDir, { codeOnly: false })
+            .then(() => { })
+            .catch((err) => {
+            console.warn('[monograph] Background build failed:', err);
         });
-        child.unref();
-        result.created.files.push('.monomind/graph/ (knowledge graph building in background)');
+        result.created.files.push('.monomind/monograph.db (knowledge graph building in background)');
     }
-    catch (_err) {
-        result.skipped.push('knowledge graph: graphify update failed');
+    catch (err) {
+        result.skipped.push('knowledge graph: monograph package unavailable');
     }
-    // 4. Start graphify watch daemon (live graph updates on file save)
-    try {
-        const watchChild = spawn('graphify', ['watch', targetDir], {
-            stdio: 'ignore',
-            detached: true,
-            cwd: targetDir,
-        });
-        watchChild.unref();
-        // Store PID so it can be stopped later
-        const { writeFileSync } = await import('fs');
-        const pidPath = path.join(outputDir, 'watch.pid');
-        writeFileSync(pidPath, String(watchChild.pid));
-        result.created.files.push('graphify watch (live graph updates on file save)');
-    }
-    catch { /* non-fatal */ }
 }
 /**
  * Start the monomind daemon with background workers.
@@ -594,11 +585,18 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                     else {
                         result.created.push(`.claude/helpers/${helperName}`);
                     }
-                    fs.copyFileSync(sourcePath, targetPath);
-                    try {
-                        fs.chmodSync(targetPath, '755');
+                    // 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);
                     }
-                    catch { }
                 }
             }
         }
@@ -617,11 +615,16 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 else {
                     result.created.push(`.claude/helpers/${helperName}`);
                 }
-                fs.writeFileSync(targetPath, content, 'utf-8');
+                // Atomic write (PID-suffixed) so a partial hook-handler.cjs cannot
+                // ship if init is interrupted, and concurrent inits don't collide on
+                // the same .tmp filename.
+                const tmp = `${targetPath}.${process.pid}.tmp`;
+                fs.writeFileSync(tmp, content, 'utf-8');
                 try {
-                    fs.chmodSync(targetPath, '755');
+                    fs.chmodSync(tmp, 0o755);
                 }
                 catch { }
+                fs.renameSync(tmp, targetPath);
             }
         }
         // 1. ALWAYS update statusline helper (force overwrite)
@@ -643,7 +646,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         else {
             result.created.push('.claude/helpers/statusline.cjs');
         }
-        fs.writeFileSync(statuslinePath, statuslineContent, 'utf-8');
+        atomicWriteFile(statuslinePath, statuslineContent);
         // 2. Create MISSING metrics files only (preserve existing data)
         const metricsDir = path.join(targetDir, '.monomind', 'metrics');
         const securityDir = path.join(targetDir, '.monomind', 'security');
@@ -659,7 +662,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 learning: { status: 'READY', patternsLearned: 0, sessionsCompleted: 0 },
                 _note: 'Metrics will update as you use Monomind'
             };
-            fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
+            atomicWriteFile(progressPath, JSON.stringify(progress, null, 2));
             result.created.push('.monomind/metrics/v1-progress.json');
         }
         else {
@@ -675,7 +678,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 integration: { agentic_flow_active: false, mcp_active: false },
                 _initialized: true
             };
-            fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
+            atomicWriteFile(activityPath, JSON.stringify(activity, null, 2));
             result.created.push('.monomind/metrics/swarm-activity.json');
         }
         else {
@@ -691,7 +694,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 sessions: { total: 0, current: null },
                 _note: 'Intelligence grows as you use Monomind'
             };
-            fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
+            atomicWriteFile(learningPath, JSON.stringify(learning, null, 2));
             result.created.push('.monomind/metrics/learning.json');
         }
         else {
@@ -708,7 +711,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 lastScan: null,
                 _note: 'Run: npx monomind@latest security scan'
             };
-            fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
+            atomicWriteFile(auditPath, JSON.stringify(audit, null, 2));
             result.created.push('.monomind/security/audit-status.json');
         }
         else {
@@ -721,7 +724,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 try {
                     const existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
                     const mergedSettings = mergeSettingsForUpgrade(existingSettings);
-                    fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
+                    atomicWriteFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
                     result.updated.push('.claude/settings.json');
                     result.settingsUpdated = [
                         'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
@@ -740,7 +743,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             else {
                 // Create new settings.json with defaults
                 const defaultSettings = generateSettings(DEFAULT_INIT_OPTIONS);
-                fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2), 'utf-8');
+                atomicWriteFile(settingsPath, JSON.stringify(defaultSettings, null, 2));
                 result.created.push('.claude/settings.json');
                 result.settingsUpdated = ['Created new settings.json with Agent Teams'];
             }
@@ -896,7 +899,7 @@ async function writeSettings(targetDir, options, result) {
                 }
             }
             if (merged) {
-                fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), 'utf-8');
+                atomicWriteFile(settingsPath, JSON.stringify(existing, null, 2));
                 result.created.files.push('.claude/settings.json (merged hooks)');
             }
             else {
@@ -905,12 +908,12 @@ async function writeSettings(targetDir, options, result) {
         }
         catch {
             // Existing file is corrupt — overwrite
-            fs.writeFileSync(settingsPath, JSON.stringify(generated, null, 2), 'utf-8');
+            atomicWriteFile(settingsPath, JSON.stringify(generated, null, 2));
             result.created.files.push('.claude/settings.json');
         }
         return;
     }
-    fs.writeFileSync(settingsPath, JSON.stringify(generated, null, 2), 'utf-8');
+    atomicWriteFile(settingsPath, JSON.stringify(generated, null, 2));
     result.created.files.push('.claude/settings.json');
 }
 /**
@@ -923,7 +926,7 @@ async function writeMCPConfig(targetDir, options, result) {
         return;
     }
     const content = generateMCPJson(options);
-    fs.writeFileSync(mcpPath, content, 'utf-8');
+    atomicWriteFile(mcpPath, content);
     result.created.files.push('.mcp.json');
 }
 /**
@@ -947,8 +950,8 @@ async function copySkills(targetDir, options, result) {
             skillsToCopy.push(...SKILLS_MAP.github);
         if (skillsConfig.browser)
             skillsToCopy.push(...SKILLS_MAP.browser);
-        if (skillsConfig.v1)
-            skillsToCopy.push(...SKILLS_MAP.v1);
+        if (skillsConfig.advanced)
+            skillsToCopy.push(...SKILLS_MAP.advanced);
     }
     // Find source skills directory
     const sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
@@ -986,20 +989,48 @@ async function copyCommands(targetDir, options, result) {
     else {
         if (commandsConfig.core)
             commandsToCopy.push(...COMMANDS_MAP.core);
+        if (commandsConfig.agents)
+            commandsToCopy.push(...(COMMANDS_MAP.agents || []));
         if (commandsConfig.analysis)
             commandsToCopy.push(...COMMANDS_MAP.analysis);
         if (commandsConfig.automation)
             commandsToCopy.push(...COMMANDS_MAP.automation);
+        if (commandsConfig.coordination)
+            commandsToCopy.push(...(COMMANDS_MAP.coordination || []));
         if (commandsConfig.github)
             commandsToCopy.push(...COMMANDS_MAP.github);
+        if (commandsConfig.hiveMind)
+            commandsToCopy.push(...(COMMANDS_MAP.hiveMind || []));
         if (commandsConfig.hooks)
             commandsToCopy.push(...COMMANDS_MAP.hooks);
+        if (commandsConfig.mastermind)
+            commandsToCopy.push(...(COMMANDS_MAP.mastermind || []));
+        if (commandsConfig.memory)
+            commandsToCopy.push(...(COMMANDS_MAP.memory || []));
         if (commandsConfig.monitoring)
             commandsToCopy.push(...COMMANDS_MAP.monitoring);
+        if (commandsConfig.monograph)
+            commandsToCopy.push(...(COMMANDS_MAP.monograph || []));
+        if (commandsConfig.monomind)
+            commandsToCopy.push(...(COMMANDS_MAP.monomind || []));
         if (commandsConfig.optimization)
             commandsToCopy.push(...COMMANDS_MAP.optimization);
+        if (commandsConfig.pair)
+            commandsToCopy.push(...(COMMANDS_MAP.pair || []));
         if (commandsConfig.sparc)
             commandsToCopy.push(...COMMANDS_MAP.sparc);
+        if (commandsConfig.streamChain)
+            commandsToCopy.push(...(COMMANDS_MAP.streamChain || []));
+        if (commandsConfig.swarm)
+            commandsToCopy.push(...(COMMANDS_MAP.swarm || []));
+        if (commandsConfig.training)
+            commandsToCopy.push(...(COMMANDS_MAP.training || []));
+        if (commandsConfig.truth)
+            commandsToCopy.push(...(COMMANDS_MAP.truth || []));
+        if (commandsConfig.verify)
+            commandsToCopy.push(...(COMMANDS_MAP.verify || []));
+        if (commandsConfig.workflows)
+            commandsToCopy.push(...(COMMANDS_MAP.workflows || []));
     }
     // Find source commands directory
     const sourceCommandsDir = findSourceDir('commands', options.sourceBaseDir);
@@ -1052,11 +1083,6 @@ async function copyAgents(targetDir, options, result) {
             agentsToCopy.push(...AGENTS_MAP.sparc);
         if (agentsConfig.swarm)
             agentsToCopy.push(...AGENTS_MAP.swarm);
-        if (agentsConfig.browser)
-            agentsToCopy.push(...AGENTS_MAP.browser);
-        // V1-specific agent categories
-        if (agentsConfig.v1)
-            agentsToCopy.push(...(AGENTS_MAP.v1 || []));
         if (agentsConfig.optimization)
             agentsToCopy.push(...(AGENTS_MAP.optimization || []));
         if (agentsConfig.testing)
@@ -1185,7 +1211,7 @@ async function writeHelpers(targetDir, options, result) {
     for (const [name, content] of Object.entries(helpers)) {
         const filePath = path.join(helpersDir, name);
         if (!fs.existsSync(filePath) || options.force) {
-            fs.writeFileSync(filePath, content, 'utf-8');
+            atomicWriteFile(filePath, content);
             // Make shell scripts executable
             if (!name.endsWith('.js')) {
                 fs.chmodSync(filePath, '755');
@@ -1268,7 +1294,7 @@ async function writeStatusline(targetDir, options, result) {
     // This must overwrite any copy from writeHelpers() which copies the legacy file.
     const statuslineScript = generateStatuslineScript(options);
     const statuslinePath = path.join(helpersDir, 'statusline.cjs');
-    fs.writeFileSync(statuslinePath, statuslineScript, 'utf-8');
+    atomicWriteFile(statuslinePath, statuslineScript);
     result.created.files.push('.claude/helpers/statusline.cjs');
 }
 /**
@@ -1324,7 +1350,7 @@ mcp:
   autoStart: ${options.mcp.autoStart}
   port: ${options.mcp.port}
 `;
-    fs.writeFileSync(configPath, config, 'utf-8');
+    atomicWriteFile(configPath, config);
     result.created.files.push('.monomind/config.yaml');
     // Write .gitignore
     const gitignorePath = path.join(targetDir, '.monomind', '.gitignore');
@@ -1337,7 +1363,7 @@ neural/
 *.tmp
 `;
     if (!fs.existsSync(gitignorePath) || options.force) {
-        fs.writeFileSync(gitignorePath, gitignore, 'utf-8');
+        atomicWriteFile(gitignorePath, gitignore);
         result.created.files.push('.monomind/.gitignore');
     }
     // Write CAPABILITIES.md with full system overview
@@ -1386,7 +1412,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             },
             _note: 'Metrics will update as you use Monomind. Run: npx monomind@latest daemon start'
         };
-        fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
+        atomicWriteFile(progressPath, JSON.stringify(progress, null, 2));
         result.created.files.push('.monomind/metrics/v1-progress.json');
     }
     // Create initial swarm-activity.json
@@ -1410,7 +1436,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             },
             _initialized: true
         };
-        fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
+        atomicWriteFile(activityPath, JSON.stringify(activity, null, 2));
         result.created.files.push('.monomind/metrics/swarm-activity.json');
     }
     // Create initial learning.json
@@ -1433,7 +1459,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             },
             _note: 'Intelligence grows as you use Monomind'
         };
-        fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
+        atomicWriteFile(learningPath, JSON.stringify(learning, null, 2));
         result.created.files.push('.monomind/metrics/learning.json');
     }
     // Create initial audit-status.json
@@ -1447,7 +1473,7 @@ async function writeInitialMetrics(targetDir, options, result) {
             lastScan: null,
             _note: 'Run: npx monomind@latest security scan'
         };
-        fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
+        atomicWriteFile(auditPath, JSON.stringify(audit, null, 2));
         result.created.files.push('.monomind/security/audit-status.json');
     }
 }
@@ -1858,7 +1884,7 @@ npx monomind@latest hooks worker dispatch --trigger optimize
 **Full Documentation**: https://github.com/nokhodian/monomind
 **Issues**: https://github.com/nokhodian/monomind/issues
 `;
-    fs.writeFileSync(capabilitiesPath, capabilities, 'utf-8');
+    atomicWriteFile(capabilitiesPath, capabilities);
     result.created.files.push('.monomind/CAPABILITIES.md');
 }
 /**
@@ -1873,7 +1899,7 @@ async function writeClaudeMd(targetDir, options, result) {
         // Determine template: explicit option > infer from components > 'standard'
         const inferredTemplate = (!options.components.commands && !options.components.agents) ? 'minimal' : undefined;
         const content = generateClaudeMd(options, inferredTemplate);
-        fs.writeFileSync(claudeMdPath, content, 'utf-8');
+        atomicWriteFile(claudeMdPath, content);
         result.created.files.push('CLAUDE.md');
     }
     // Also write/append global ~/.claude/CLAUDE.md so monomind tools are used automatically (#1497)
@@ -1901,7 +1927,7 @@ async function writeClaudeMd(targetDir, options, result) {
                 }
             }
             else {
-                fs.writeFileSync(globalClaudeMd, monomindBlock.trimStart(), 'utf-8');
+                atomicWriteFile(globalClaudeMd, monomindBlock.trimStart());
                 result.created.files.push('~/.claude/CLAUDE.md');
             }
         }
@@ -1932,7 +1958,7 @@ async function writeClaudeMd(targetDir, options, result) {
                 });
                 hooks['SessionStart'] = sessionStartHooks;
                 globalSettings.hooks = hooks;
-                fs.writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2), 'utf-8');
+                atomicWriteFile(globalSettingsPath, JSON.stringify(globalSettings, null, 2));
                 result.created.files.push('~/.claude/settings.json (added token hook)');
             }
         }