monomind 1.9.3 → 1.9.5

package/.claude/helpers/graphify-freshen.cjs

@@ -52,8 +52,29 @@ if (!entryPoint) {
   process.exit(0);
 }
 
+// Skip if another build is already in progress (avoids SQLite BUSY on concurrent init + session-start)
+const lockPath = path.join(graphDir, 'build.lock');
+const now = Date.now();
+try {
+  const stat = fs.statSync(lockPath);
+  // Stale lock older than 5 minutes — remove it and proceed
+  if (now - stat.mtimeMs < 5 * 60 * 1000) {
+    console.log('[graph] build already in progress — skipping');
+    process.exit(0);
+  }
+  fs.unlinkSync(lockPath);
+} catch { /* lock does not exist — proceed */ }
+
+// Write lock file; the build process removes it on completion
+try { fs.writeFileSync(lockPath, String(process.pid)); } catch { /* non-fatal */ }
+
 // Spawn a detached node process to run buildAsync from @monoes/monograph (ESM)
-const script = `import { buildAsync } from ${JSON.stringify('file://' + entryPoint)}; await buildAsync(${JSON.stringify(projectDir)});`;
+const script = `
+import { buildAsync } from ${JSON.stringify('file://' + entryPoint)};
+import { unlinkSync } from 'fs';
+try { await buildAsync(${JSON.stringify(projectDir)}); } finally {
+  try { unlinkSync(${JSON.stringify(lockPath)}); } catch {}
+}`;
 const child = spawn(process.execPath, ['--input-type=module', '--eval', script], {
   detached: true,
   stdio: ['ignore', logFd, logFd],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "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

@@ -89,18 +89,14 @@ const initAction = async (ctx) => {
             return { success: false, exitCode: 1 };
         }
         spinner.succeed('Monomind initialized successfully!');
-        // Trigger background monograph build + continuous watch
+        // Trigger background monograph watch (includes initial build on start).
+        // Only one spawn — avoids SQLite BUSY from concurrent build + watch + session-start hook.
         try {
             const { spawn } = await import('child_process');
-            for (const args of [
-                ['monograph', 'build', '--code-only'],
-                ['monograph', 'watch'],
-            ]) {
-                const proc = spawn(process.execPath, [process.argv[1], ...args], {
-                    detached: true, stdio: 'ignore', cwd: ctx.cwd, env: process.env,
-                });
-                proc.unref();
-            }
+            const proc = spawn(process.execPath, [process.argv[1], 'monograph', 'watch'], {
+                detached: true, stdio: 'ignore', cwd: ctx.cwd, env: process.env,
+            });
+            proc.unref();
             output.printInfo('◈ Building knowledge graph in background… (watch mode active)');
         }
         catch {

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

@@ -350,25 +350,62 @@ export async function executeInit(options) {
     return result;
 }
 /**
- * Initialize the Monograph knowledge graph (native TypeScript, no Python required).
- * Fire-and-forget build — init does not wait for it to complete.
+ * Initialize the Monograph knowledge graph.
+ * Spawns buildAsync as a detached child process to avoid SQLite lock contention.
+ * Uses the same build.lock file as graphify-freshen.cjs — if a session-start
+ * hook build is already running, we skip to avoid SQLITE_BUSY.
  */
 async function initKnowledgeGraph(targetDir, result) {
-    const { mkdirSync } = await import('fs');
+    const { mkdirSync, statSync, unlinkSync, writeFileSync, existsSync } = await import('fs');
     const outputDir = path.join(targetDir, '.monomind', 'graph');
     mkdirSync(outputDir, { recursive: true });
+    const lockPath = path.join(outputDir, 'build.lock');
+    const now = Date.now();
+    // If graphify-freshen.cjs (session-start hook) already holds a fresh lock, skip.
     try {
-        const { buildAsync } = await import('@monoes/monograph');
-        buildAsync(targetDir, { codeOnly: false })
-            .then(() => { })
-            .catch((err) => {
-            console.warn('[monograph] Background build failed:', err);
-        });
-        result.created.files.push('.monomind/monograph.db (knowledge graph building in background)');
+        const stat = statSync(lockPath);
+        if (now - stat.mtimeMs < 5 * 60 * 1000) {
+            result.skipped.push('knowledge graph build: already in progress (session-start hook running)');
+            return;
+        }
+        unlinkSync(lockPath);
+    }
+    catch { /* no lock — proceed */ }
+    // Resolve @monoes/monograph from the CLI package's own node_modules first
+    // (correct for npm/npx installs), then fall back to user project node_modules.
+    let entryPoint = null;
+    try {
+        const cliRequire = createRequire(import.meta.url);
+        entryPoint = cliRequire.resolve('@monoes/monograph/dist/src/index.js');
     }
-    catch (err) {
-        result.skipped.push('knowledge graph: monograph package unavailable');
+    catch {
+        const fallback = path.join(targetDir, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js');
+        if (existsSync(fallback))
+            entryPoint = fallback;
+    }
+    if (!entryPoint) {
+        result.skipped.push('knowledge graph: @monoes/monograph not found');
+        return;
     }
+    // Acquire lock before spawning so graphify-freshen.cjs sees it and skips
+    try {
+        writeFileSync(lockPath, String(process.pid));
+    }
+    catch { /* non-fatal */ }
+    const { spawn } = await import('child_process');
+    const script = `
+import { buildAsync } from ${JSON.stringify('file://' + entryPoint)};
+import { unlinkSync } from 'fs';
+try { await buildAsync(${JSON.stringify(targetDir)}); } finally {
+  try { unlinkSync(${JSON.stringify(lockPath)}); } catch {}
+}`;
+    const child = spawn(process.execPath, ['--input-type=module', '--eval', script], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: targetDir,
+    });
+    child.unref();
+    result.created.files.push('.monomind/graph/ (knowledge graph building in background)');
 }
 /**
  * Start the monomind daemon with background workers.

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

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