monomind 1.14.3 → 1.14.5

package/.claude/commands/mastermind/runorg.md

@@ -93,7 +93,8 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg org "$org_name" \
-    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),ts:(now*1000|floor)}')" || true
+    --arg proj "$(pwd)" \
+    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
 Invoke `Skill("mastermind:runorg")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
@@ -105,7 +106,8 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg status "<status>" \
-    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],ts:(now*1000|floor)}')" || true
+    --arg proj "$(pwd)" \
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
 Follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/_repeat.md

@@ -44,10 +44,11 @@ Set `TILLEND_EMPTY=true` **only if BOTH are zero for this round**.
   ```
 - Emit dashboard event (non-fatal if control server is not running):
   ```bash
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$(git rev-parse --show-toplevel 2>/dev/null || echo ".")/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
     -H "Content-Type: application/json" \
-    -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"empty-round\",\"ts\":$(date +%s)000}" || true
+    -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"empty-round\",\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
   ```
 - Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
 - **END**.
@@ -73,10 +74,11 @@ If `current_rep >= repeat_count`:
 - Output: `[repeat] All <repeat_count> runs of /<command> complete.`
 - Emit dashboard event:
   ```bash
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$(git rev-parse --show-toplevel 2>/dev/null || echo ".")/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
     -H "Content-Type: application/json" \
-    -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"ts\":$(date +%s)000}" || true
+    -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
   ```
 - Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
 - **END**.
@@ -120,10 +122,11 @@ EOF
 
 Emit `loop:tick`:
 ```bash
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$(git rev-parse --show-toplevel 2>/dev/null || echo ".")/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
 curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
-  -d "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"completedRep\":<current_rep>,\"nextRep\":<next_rep>,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true
+  -d "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"completedRep\":<current_rep>,\"nextRep\":<next_rep>,\"nextAt\":${NEXT_AT},\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
 ```
 
 **Call `ScheduleWakeup` now** — this is a mandatory tool call:

package/.claude/skills/mastermind/runorg.md

@@ -501,13 +501,13 @@ OPERATING LOOP:
           # On start — announce you are working:
           curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
             -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
-              --arg from "<role_id>" --arg msg "Starting: <card title>" \
-              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,ts:(now*1000|floor)}')" || true
+              --arg from "<role_id>" --arg msg "Starting: <card title>" --arg p "$REPO_ROOT" \
+              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,project:$p,ts:(now*1000|floor)}')" || true
           # On completion — report back:
           curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
             -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
-              --arg from "<role_id>" --arg msg "Completed: <one-sentence summary of output>" \
-              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,ts:(now*1000|floor)}')" || true
+              --arg from "<role_id>" --arg msg "Completed: <one-sentence summary of output>" --arg p "$REPO_ROOT" \
+              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,project:$p,ts:(now*1000|floor)}')" || true
 
         Fill in the literal values for orgName="${orgName}", runId="${runId}", sessionId="${sessionId}" — embed them
         directly in the prompt string so the specialist doesn't need to resolve them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.14.3",
+  "version": "1.14.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",
@@ -147,4 +147,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

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

@@ -1,93 +1,114 @@
 import { output } from '../output.js';
 import { existsSync, unlinkSync, rmSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
-
 const orgCommand = {
-  name: 'org',
-  description: 'Manage monomind organisations',
-  subcommands: ['delete', 'list'],
-  usage: 'monomind org <subcommand> [options]',
-  examples: [
-    'monomind org list',
-    'monomind org delete my-org',
-    'monomind org delete my-org --yes',
-  ],
-
-  async execute(args, context) {
-    const sub = args[0];
-
-    if (!sub || sub === 'help') {
-      output.info('Usage: monomind org <subcommand>');
-      output.info('');
-      output.info('Subcommands:');
-      output.info('  list              List all orgs in the current project');
-      output.info('  delete <name>     Delete an org and all its data');
-      return { success: true };
-    }
-
-    if (sub === 'list') {
-      const cwd = context?.projectPath || process.cwd();
-      const orgsDir = join(cwd, '.monomind', 'orgs');
-      if (!existsSync(orgsDir)) {
-        output.info('No orgs directory found. Create an org first with /mastermind:createorg');
-        return { success: true };
-      }
-      const ignore = ['-state','-goals','-threads','-activity','-approvals','-members','-secrets','-budgets','-routines','-issues','-projects','-workspaces','-worktrees','-environments','-plugins','-adapters','-join-requests','-bootstrap','-project-workspaces','-approval-comments','-skills'];
-      const configs = readdirSync(orgsDir)
-        .filter(f => f.endsWith('.json') && !ignore.some(s => f.includes(s)));
-      if (!configs.length) { output.info('No orgs found.'); return { success: true }; }
-      output.info(`Found ${configs.length} org(s):`);
-      for (const f of configs) output.info(`  • ${f.replace('.json', '')}`);
-      return { success: true };
-    }
-
-    if (sub === 'delete') {
-      const orgName = args[1];
-      if (!orgName) {
-        output.error('Usage: monomind org delete <name>');
-        return { success: false, error: 'org name required' };
-      }
-      if (!/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
-        output.error(`Invalid org name: ${orgName}`);
-        return { success: false, error: 'invalid org name' };
-      }
-
-      const confirmed = args.includes('--yes') || args.includes('-y');
-      if (!confirmed) {
-        output.warn(`This will permanently delete org "${orgName}" and all its data.`);
-        output.warn('Pass --yes to confirm.');
-        return { success: false, error: 'confirmation required' };
-      }
-
-      const cwd = resolve(context?.projectPath || process.cwd());
-      const orgsDir = join(cwd, '.monomind', 'orgs');
-      const configFile = join(orgsDir, `${orgName}.json`);
-      if (!existsSync(configFile)) {
-        output.error(`Org not found: ${orgName}`);
-        return { success: false, error: 'org not found' };
-      }
-
-      const suffixes = ['','-state','-goals','-routines','-approvals','-activity','-issues','-members','-projects','-workspaces','-worktrees','-environments','-plugins','-adapters','-budgets','-threads','-secrets','-join-requests','-bootstrap','-project-workspaces','-approval-comments','-skills'];
-      let removed = 0;
-      for (const suf of suffixes) {
-        for (const ext of ['.json', '.jsonl']) {
-          const f = join(orgsDir, `${orgName}${suf}${ext}`);
-          try { if (existsSync(f)) { unlinkSync(f); removed++; } } catch (_) {}
+    name: 'org',
+    description: 'Manage monomind organisations',
+    subcommands: ['delete', 'list'],
+    usage: 'monomind org <subcommand> [options]',
+    examples: [
+        'monomind org list',
+        'monomind org delete my-org',
+        'monomind org delete my-org --yes',
+    ],
+    async execute(args, context) {
+        const sub = args[0];
+        if (!sub || sub === 'help') {
+            output.info('Usage: monomind org <subcommand>');
+            output.info('');
+            output.info('Subcommands:');
+            output.info('  list              List all orgs in the current project');
+            output.info('  delete <name>     Delete an org and all its data');
+            return { success: true };
         }
-      }
-      try { unlinkSync(join(orgsDir, '.stops', `${orgName}.stop`)); } catch (_) {}
-      const orgSubDir = join(orgsDir, orgName);
-      try { if (existsSync(orgSubDir)) rmSync(orgSubDir, { recursive: true, force: true }); } catch (_) {}
-      try { unlinkSync(join(cwd, '.monomind', 'loops', `${orgName}.md`)); } catch (_) {}
-      try { unlinkSync(join(cwd, '.monomind', 'orgs', `${orgName}-run.md`)); } catch (_) {}
-
-      output.success(`Org "${orgName}" deleted (${removed} file(s) removed).`);
-      return { success: true };
-    }
-
-    output.error(`Unknown subcommand: ${sub}. Run "monomind org help" for usage.`);
-    return { success: false, error: `unknown subcommand: ${sub}` };
-  },
+        if (sub === 'list') {
+            const cwd = context.projectPath || process.cwd();
+            const orgsDir = join(cwd, '.monomind', 'orgs');
+            if (!existsSync(orgsDir)) {
+                output.info('No orgs directory found. Create an org first with /mastermind:createorg');
+                return { success: true };
+            }
+            const configs = readdirSync(orgsDir)
+                .filter(f => f.endsWith('.json') && !f.includes('-state') && !f.includes('-goals')
+                && !f.includes('-threads') && !f.includes('-activity') && !f.includes('-approvals')
+                && !f.includes('-members') && !f.includes('-secrets') && !f.includes('-budgets'));
+            if (!configs.length) {
+                output.info('No orgs found.');
+                return { success: true };
+            }
+            output.info(`Found ${configs.length} org(s):`);
+            for (const f of configs)
+                output.info(`  • ${f.replace('.json', '')}`);
+            return { success: true };
+        }
+        if (sub === 'delete') {
+            const orgName = args[1];
+            if (!orgName) {
+                output.error('Usage: monomind org delete <name>');
+                return { success: false, error: 'org name required' };
+            }
+            if (!/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+                output.error(`Invalid org name: ${orgName}`);
+                return { success: false, error: 'invalid org name' };
+            }
+            const confirmed = args.includes('--yes') || args.includes('-y');
+            if (!confirmed) {
+                output.warn(`This will permanently delete org "${orgName}" and all its data.`);
+                output.warn('Pass --yes to confirm.');
+                return { success: false, error: 'confirmation required' };
+            }
+            const cwd = resolve(context.projectPath || process.cwd());
+            const orgsDir = join(cwd, '.monomind', 'orgs');
+            const configFile = join(orgsDir, `${orgName}.json`);
+            if (!existsSync(configFile)) {
+                output.error(`Org not found: ${orgName}`);
+                return { success: false, error: 'org not found' };
+            }
+            const suffixes = ['', '-state', '-goals', '-routines', '-approvals', '-activity',
+                '-issues', '-members', '-projects', '-workspaces', '-worktrees', '-environments',
+                '-plugins', '-adapters', '-budgets', '-threads', '-secrets', '-join-requests',
+                '-bootstrap', '-project-workspaces', '-approval-comments', '-skills'];
+            let removed = 0;
+            for (const suf of suffixes) {
+                for (const ext of ['.json', '.jsonl']) {
+                    const f = join(orgsDir, `${orgName}${suf}${ext}`);
+                    try {
+                        if (existsSync(f)) {
+                            unlinkSync(f);
+                            removed++;
+                        }
+                    }
+                    catch (_) { }
+                }
+            }
+            // Remove stop file
+            try {
+                unlinkSync(join(orgsDir, '.stops', `${orgName}.stop`));
+            }
+            catch (_) { }
+            // Remove org subdirectory
+            const orgSubDir = join(orgsDir, orgName);
+            try {
+                if (existsSync(orgSubDir))
+                    rmSync(orgSubDir, { recursive: true, force: true });
+            }
+            catch (_) { }
+            // Remove loop prompt file
+            try {
+                unlinkSync(join(cwd, '.monomind', 'loops', `${orgName}.md`));
+            }
+            catch (_) { }
+            // Remove run prompt file
+            try {
+                unlinkSync(join(cwd, '.monomind', 'orgs', `${orgName}-run.md`));
+            }
+            catch (_) { }
+            output.success(`Org "${orgName}" deleted (${removed} file(s) removed).`);
+            return { success: true };
+        }
+        output.error(`Unknown subcommand: ${sub}. Run "monomind org help" for usage.`);
+        return { success: false, error: `unknown subcommand: ${sub}` };
+    },
 };
-
 export default orgCommand;
+//# sourceMappingURL=org.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-tools.js

@@ -544,10 +544,58 @@ const monographReportTool = {
         }
     },
 };
+// ── Shared staleness helper ───────────────────────────────────────────────────
+/** Guard against concurrent background buildAsync calls on the same DB. */
+let _buildInProgress = false;
+/**
+ * Compute how many commits the index is behind HEAD.
+ * Returns { commitsBehind, lastCommit } — or null if the index has never been
+ * built or git is unavailable.
+ */
+async function computeCommitsBehind(repoPath) {
+    const { openDb, closeDb } = await import('@monoes/monograph');
+    const { execSync } = await import('child_process');
+    const db = openDb(join(repoPath, '.monomind', 'monograph.db'));
+    try {
+        const meta = db.prepare("SELECT value FROM index_meta WHERE key = 'last_commit_hash'").get() ?? db.prepare("SELECT value FROM index_meta WHERE key = 'lastCommit'").get();
+        const lastCommit = meta?.value ?? null;
+        if (!lastCommit || !/^[0-9a-f]{7,40}$/i.test(lastCommit))
+            return null;
+        try {
+            const out = execSync(`git rev-list --count ${lastCommit}..HEAD`, {
+                cwd: repoPath, encoding: 'utf-8',
+            }).trim();
+            return { commitsBehind: parseInt(out, 10), lastCommit };
+        }
+        catch {
+            return null;
+        }
+    }
+    finally {
+        closeDb(db);
+    }
+}
+/**
+ * Fire-and-forget background rebuild. Uses a module-level guard so concurrent
+ * MCP tool calls (e.g. repeated monograph_suggest_auto) don't pile up builds.
+ * threshold: minimum commitsBehind to trigger (default 1, Task 2 uses 10).
+ */
+function triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, threshold = 1) {
+    if (commitsBehind < threshold)
+        return false;
+    if (_buildInProgress)
+        return false;
+    _buildInProgress = true;
+    void import('@monoes/monograph')
+        .then(({ buildAsync }) => buildAsync(repoPath, { codeOnly: true }))
+        .catch(() => { })
+        .finally(() => { _buildInProgress = false; });
+    return true;
+}
 // ── monograph_staleness ───────────────────────────────────────────────────────
 const monographStalenessTool = {
     name: 'monograph_staleness',
-    description: 'Git staleness detection: compares the commit hash at last index build against current HEAD. Returns isStale, changed files, and the timestamp of first diverging commit.',
+    description: 'Git staleness detection: compares the commit hash at last index build against current HEAD. When the index is more than 10 commits behind HEAD it automatically triggers a background rebuild. Returns { commitsBehind, status, triggered }.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -555,26 +603,16 @@ const monographStalenessTool = {
         },
     },
     handler: async (input) => {
-        const { getMonographStaleness } = await import('@monoes/monograph');
         const repoPath = input.path ?? getProjectCwd();
-        const r = await getMonographStaleness(repoPath);
-        if (!r.indexedCommit && !r.currentCommit) {
-            return text('Index has never been built or repo has no git history. Run monograph_build first.');
-        }
-        const statusLine = r.isStale
-            ? `STALE — index at ${r.indexedCommit}, HEAD at ${r.currentCommit}`
-            : `FRESH — index matches HEAD (${r.currentCommit})`;
-        const lines = [`Staleness: ${statusLine}`];
-        if (r.staleSince)
-            lines.push(`Stale since: ${r.staleSince}`);
-        if (r.changedSince.length > 0) {
-            const shown = r.changedSince.slice(0, 10);
-            const more = r.changedSince.length - shown.length;
-            lines.push(`Changed files (${r.changedSince.length}):${shown.map(f => `\n  ${f}`).join('')}${more > 0 ? `\n  … ${more} more` : ''}`);
-        }
-        if (r.isStale)
-            lines.push('Action: run monograph_build to re-index');
-        return text(lines.join('\n'));
+        const result = await computeCommitsBehind(repoPath);
+        if (!result) {
+            return text(JSON.stringify({ commitsBehind: 0, status: 'unknown', triggered: false }));
+        }
+        const { commitsBehind } = result;
+        const AUTO_BUILD_THRESHOLD = 10;
+        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, AUTO_BUILD_THRESHOLD + 1);
+        const status = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
+        return text(JSON.stringify({ commitsBehind, status, triggered }));
     },
 };
 // ── monograph_snapshot ────────────────────────────────────────────────────────
@@ -1735,6 +1773,38 @@ const monographNeighborsTool = {
         }
     },
 };
+// ── monograph_suggest_auto ────────────────────────────────────────────────────
+const monographSuggestAutoTool = {
+    name: 'monograph_suggest_auto',
+    description: 'Like monograph_suggest but health-aware: checks staleness first and triggers a background rebuild when the index is behind HEAD before returning suggestions. Result includes a _staleness annotation.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Optional task description for task-relevance scoring' },
+            limit: { type: 'number', description: 'Max questions (default 10)' },
+        },
+    },
+    handler: async (input) => {
+        const repoPath = getProjectCwd();
+        // Check staleness and trigger rebuild if needed (threshold: any staleness).
+        const stalenessResult = await computeCommitsBehind(repoPath);
+        const commitsBehind = stalenessResult?.commitsBehind ?? 0;
+        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, 1);
+        const stalenessStatus = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
+        // Delegate to the base suggest tool — no logic duplication.
+        const baseResult = await monographSuggestTool.handler(input);
+        // Append staleness annotation to the text content.
+        const stalenessAnnotation = `\n_staleness: ${JSON.stringify({ commitsBehind, status: stalenessStatus, triggered })}`;
+        if (baseResult && Array.isArray(baseResult.content)) {
+            const content = baseResult.content;
+            if (content.length > 0 && content[0].type === 'text') {
+                content[0].text += stalenessAnnotation;
+            }
+            return baseResult;
+        }
+        return baseResult;
+    },
+};
 // ── Export all tools ──────────────────────────────────────────────────────────
 export const monographTools = [
     monographBuildTool,
@@ -1747,6 +1817,7 @@ export const monographTools = [
     monographCommunityTool,
     monographSurprisesTool,
     monographSuggestTool,
+    monographSuggestAutoTool,
     monographVisualizeTool,
     monographWatchTool,
     monographWatchStopTool,

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.14.3",
+  "version": "1.14.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",
@@ -104,4 +104,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}