monomind 1.18.13 → 1.18.15

package/packages/@monomind/cli/.claude/commands/mastermind/taskdev.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:taskdev")` passing: brain_context, plan_file, p
 
 After skill returns: follow `_protocol.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/tdd.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:tdd")` passing: brain_context, feature_or_bug,
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `tdd`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/verify.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:verify")` passing: brain_context, claim_or_task
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `verify`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/helpers/graphify-freshen.cjs

@@ -70,27 +70,23 @@ if (!entryPoint) {
 const dbPath = path.join(projectDir, '.monomind', 'monograph.db');
 if (fs.existsSync(dbPath)) {
   try {
-    const mod = (() => {
-      try { return require(path.join(projectDir, 'packages', '@monomind', 'monograph', 'dist', 'src', 'index.js')); } catch {}
-      try { return require('@monoes/monograph'); } catch {}
-      return null;
-    })();
-    if (mod && mod.openDb) {
-      const db = mod.openDb(dbPath);
-      try {
-        const row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get();
-        if (row && row.value) {
-          const { execSync } = require('child_process');
-          const behind = parseInt(execSync('git rev-list --count ' + row.value + '..HEAD 2>/dev/null', {
-            cwd: projectDir, encoding: 'utf-8', timeout: 2000
-          }).trim(), 10) || 0;
-          if (behind === 0) {
-            console.log('[graph] index is fresh — skipping rebuild');
-            process.exit(0);
-          }
+    const Database = require(require.resolve('better-sqlite3', { paths: [path.dirname(entryPoint)] }));
+    const db = new Database(dbPath, { readonly: true, timeout: 5000 });
+    try {
+      const row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get();
+      if (row && row.value && /^[0-9a-f]{7,40}$/i.test(row.value)) {
+        const { execFileSync } = require('child_process');
+        const out = execFileSync('git', ['rev-list', '--count', row.value + '..HEAD'], {
+          cwd: projectDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        const behind = parseInt(out, 10);
+        if (behind === 0) {
+          console.log('[graph] index is fresh — skipping rebuild');
+          db.close();
+          process.exit(0);
         }
-      } finally { mod.closeDb(db); }
-    }
+      }
+    } finally { try { db.close(); } catch {} }
   } catch { /* can't check — proceed with build */ }
 }
 

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -361,17 +361,14 @@ module.exports = {
       // Source of truth is .monomind/monograph.db (SQLite). Legacy stats.json
       // is no longer written by the build, so it is checked only as a fallback.
       try {
-        var monographDb = path.join(CWD, '.monomind', 'monograph.db');
         var legacyStats = path.join(CWD, '.monomind', 'graph', 'stats.json');
         var nodeCount = 0;
-        if (fs.existsSync(monographDb)) {
-          try {
-            var hintDb = hCtx._openMonographDb();
-            if (hintDb) {
-              nodeCount = hintDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
-            }
-          } catch (e) { /* ignore — fall back to legacy */ }
-        }
+        try {
+          var hintDb = hCtx._openMonographDb();
+          if (hintDb) {
+            nodeCount = hintDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+          }
+        } catch (e) { /* ignore — fall back to legacy */ }
         if (nodeCount === 0 && fs.existsSync(legacyStats)) {
           try {
             var legacyStatsSt = fs.statSync(legacyStats);

package/packages/@monomind/cli/.claude/helpers/utils/monograph.cjs

@@ -49,11 +49,28 @@ function _suggestCacheSet(key, value) {
   }
   _suggestCache._map[key] = value;
 }
+function _isValidDb(p) {
+  try { return fs.statSync(p).size >= 100; } catch (_) { return false; }
+}
+
+function _resolveDbPath() {
+  // monolean: try CWD first, then git root, so hooks work from any subdirectory
+  var candidate = path.join(CWD, '.monomind', 'monograph.db');
+  if (_isValidDb(candidate)) return candidate;
+  try {
+    var { execSync } = require('child_process');
+    var root = execSync('git rev-parse --show-toplevel', { cwd: CWD, encoding: 'utf-8', timeout: 2000 }).trim();
+    candidate = path.join(root, '.monomind', 'monograph.db');
+    if (_isValidDb(candidate)) return candidate;
+  } catch (_) {}
+  return null;
+}
+
 function _openMonographDb() {
   if (_cachedMonographDb !== undefined) return _cachedMonographDb;
   try {
-    var dbPath = path.join(CWD, '.monomind', 'monograph.db');
-    if (!fs.existsSync(dbPath)) { _cachedMonographDb = null; return null; }
+    var dbPath = _resolveDbPath();
+    if (!dbPath) { _cachedMonographDb = null; return null; }
     var mod = _requireMonograph();
     if (!mod || !mod.openDb) { _cachedMonographDb = null; return null; }
     _cachedMonographDb = mod.openDb(dbPath);
@@ -189,27 +206,30 @@ function _isGraphFresh() {
   if (_graphFreshnessCache !== undefined) return _graphFreshnessCache;
   try {
     var db = _openMonographDb();
-    if (!db) { _graphFreshnessCache = true; return true; }
+    if (!db) { _graphFreshnessCache = false; return false; }
     var row = null;
     try {
       row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get() ||
             db.prepare("SELECT value FROM index_meta WHERE key='lastCommit'").get();
     } catch (_) {}
     if (!row || !row.value) {
-      // No commit hash → can't check staleness, but DB may still have useful data
-      var nodeCount = 0;
-      try { nodeCount = db.prepare('SELECT COUNT(*) AS c FROM nodes').get().c; } catch (_) {}
-      _graphFreshnessCache = nodeCount > 0;
-      return _graphFreshnessCache;
+      _graphFreshnessCache = false;
+      return false;
     }
-    var { execSync } = require('child_process');
-    var out = execSync('git rev-list --count ' + row.value + '..HEAD 2>/dev/null', {
-      encoding: 'utf-8', timeout: 1500, stdio: ['pipe', 'pipe', 'pipe']
+    if (!/^[0-9a-f]{7,40}$/i.test(row.value)) {
+      _graphFreshnessCache = false;
+      return false;
+    }
+    var { execFileSync } = require('child_process');
+    var out = execFileSync('git', ['rev-list', '--count', row.value + '..HEAD'], {
+      encoding: 'utf-8', timeout: 1500, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD
     }).trim();
-    var behind = parseInt(out, 10) || 0;
+    var behind = parseInt(out, 10);
+    if (isNaN(behind)) { _graphFreshnessCache = false; return false; }
     _graphFreshnessCache = behind <= 50;
   } catch(e) {
-    _graphFreshnessCache = true; // can't check → assume fresh
+    // Don't cache transient errors — let next call retry
+    return false;
   }
   return _graphFreshnessCache;
 }
@@ -369,21 +389,18 @@ function injectGodNodesContext(CWD) {
       // Precompute degree via indexed edge lookups to avoid O(N) correlated subquery
       var godNodes = db.prepare(
         "WITH deg AS (" +
-        "  SELECT id, cnt FROM (" +
+        "  SELECT id, SUM(cnt) AS deg FROM (" +
         "    SELECT source_id AS id, COUNT(*) AS cnt FROM edges GROUP BY source_id " +
         "    UNION ALL " +
         "    SELECT target_id AS id, COUNT(*) AS cnt FROM edges GROUP BY target_id" +
         "  ) GROUP BY id" +
-        "  HAVING SUM(cnt) > 0" +
-        "), ranked AS (" +
-        "  SELECT d.id, SUM(d.cnt) AS deg FROM deg d GROUP BY d.id ORDER BY deg DESC LIMIT 50" +
         ") " +
-        "SELECT n.name, n.label, n.file_path, r.deg " +
-        "FROM ranked r JOIN nodes n ON n.id = r.id " +
+        "SELECT n.name, n.label, n.file_path, d.deg " +
+        "FROM deg d JOIN nodes n ON n.id = d.id " +
         "WHERE n.label NOT IN ('Concept') " +
         "AND n.file_path IS NOT NULL AND n.file_path != '' " +
         "AND n.file_path NOT LIKE '%/node_modules/%' AND n.file_path NOT LIKE '%node_modules%' " +
-        "ORDER BY r.deg DESC LIMIT 12"
+        "ORDER BY d.deg DESC LIMIT 12"
       ).all();
 
       // Staleness indicator: compare stored commit hash with current HEAD.

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_repeat.md

@@ -6,6 +6,21 @@ type: protocol-skill
 
 # REPEAT POSTAMBLE
 
+<EXTREMELY-IMPORTANT>
+## MANDATORY EXECUTION — READ THIS FIRST
+
+This postamble is **not optional**. You MUST execute every step below. You MUST call ScheduleWakeup unless a legitimate stop condition is met (stop file, empty round confirmed by git, or count reached).
+
+**Anti-rationalization rules:**
+- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
+- "The skill already handled everything" is NOT a reason to skip this postamble.
+- "There's nothing more to do" is NOT your decision — the tillend check decides.
+- For `--repeat N`: you MUST run all N iterations. The count is non-negotiable. You cannot stop at run 3 of 5 because you think 3 was enough.
+- For `--tillend`: you MUST continue until git AND your assessment BOTH confirm an empty round. Your feeling that "it's probably clean" is not evidence.
+
+If you are about to end your response without calling ScheduleWakeup and you have not hit a legitimate stop condition, **YOU ARE MAKING AN ERROR. Go back and call ScheduleWakeup.**
+</EXTREMELY-IMPORTANT>
+
 **If neither `tillend_mode = true` nor `repeat_count ≥ 2` was active in this invocation, stop immediately — this skill is a no-op.**
 
 Otherwise execute all steps below before ending the response.
@@ -29,12 +44,22 @@ If the stop file exists:
 
 **`LOOP_ASYNC_PENDING` escape hatch:** If the calling skill set `LOOP_ASYNC_PENDING=true` before invoking this postamble (because it spawned background agents whose results have not yet arrived), skip the empty-round check and go directly to Step 4 to schedule the next run. Output: `[tillend] Async work in flight — deferring empty-round check to run <next_rep>.`
 
-Evaluate now whether this run produced **zero findings AND zero actions**:
+**Step 2a — Machine verification (REQUIRED before any self-assessment):**
+
+Run this command to get an objective signal of whether files changed during this run:
+
+```bash
+GIT_CHANGES=$(git diff --stat HEAD 2>/dev/null; git diff --cached --stat 2>/dev/null; git status --porcelain 2>/dev/null | grep -v '^\?\?' | head -20)
+echo "GIT_CHANGES_DURING_RUN: ${GIT_CHANGES:-NONE}"
+```
+
+If `GIT_CHANGES` is non-empty, files were modified — `TILLEND_EMPTY=false` regardless of your self-assessment. Skip to "Otherwise" below.
+
+**Step 2b — Self-assessment (only if git shows no changes):**
 
-- **Findings**: issues found, problems detected, items flagged, security vulnerabilities, tasks discovered, errors reported
-- **Actions**: files edited, code fixed, commits made, tasks created, configs changed, content written
+Only if `GIT_CHANGES` was empty, evaluate whether this run produced findings (issues identified, problems flagged) or actions (tasks created, content written, configs changed — anything not captured by git diff).
 
-Set `TILLEND_EMPTY=true` **only if BOTH are zero for this round**.
+Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment confirms zero findings and zero actions**.
 
 **Important**: If this round found things AND fixed them, `TILLEND_EMPTY=false` — the loop must continue to verify the fixes didn't introduce new issues.
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/review.md

@@ -171,8 +171,15 @@ Step 4 — Report:
 
 Also run /mastermind:do --board <board_id> to track execution.
 
-STEP 4 — COLLECT AND RETURN
-Synthesize all review findings. Return to caller:
+STEP 4 — AUTO-FIX (mode = auto only, skip for mode = confirm)
+When mode is auto: for each fixable finding from the review (code bugs, style issues, security vulnerabilities with clear fixes), apply the fix directly by editing the file. Do NOT ask the user for permission — auto mode means fix without asking. After fixing, output:
+  [review] Auto-fixed N issues. M issues remain (require manual intervention or are architectural).
+Non-fixable findings (design questions, trade-offs, architectural concerns) are reported but left untouched.
+
+When --tillend is active, this step is critical: without auto-fixing, the loop either finds the same issues every round (infinite loop) or falsely declares empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
+
+STEP 5 — COLLECT AND RETURN
+Synthesize all review findings and fixes applied. Return to caller:
 
 domain: review
 status: complete | partial | blocked
@@ -183,12 +190,14 @@ decisions:
   - what: [critical findings and recommended actions]
     why: [evidence from review]
     confidence: [0.0-1.0]
-    outcome: pending
+    outcome: fixed | pending | manual
 lessons:
   - what_worked: [which review angles surfaced the most value]
   - what_didnt: [gaps in review coverage]
+fixes_applied: [count of auto-fixed issues]
+fixes_remaining: [count of issues needing manual intervention]
 next_actions:
-  - [e.g. "run mastermind:build to fix critical issues found"]
+  - [e.g. "re-run review to verify fixes" if tillend is active]
   - [e.g. "run mastermind:release after fixes are confirmed"]
 board_url: monotask://<project_name>/review
 run_id: <ISO8601-timestamp>`,
@@ -203,8 +212,10 @@ run_id: <ISO8601-timestamp>`,
 For simple tasks (single reviewer, single artifact):
 
 1. Spawn one Task agent with the review request as a self-contained briefing
-2. Collect output
-3. Return unified output schema with `status: complete`
+2. Collect findings
+3. **If mode = auto**: apply fixes for all fixable findings directly (do NOT ask the user). Output: `[review] Auto-fixed N issues.`
+4. **If mode = confirm**: present findings and ask which to fix
+5. Return unified output schema with `status: complete`
 
 ---
 

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

@@ -5,9 +5,37 @@
  * All monograph_* tools are backed by @monoes/monograph package.
  */
 import { join, resolve, sep } from 'path';
+import { execSync } from 'child_process';
+import { statSync } from 'fs';
 import { getProjectCwd } from './types.js';
+let _cachedDbPath;
+function _isValidDb(p) {
+    try {
+        return statSync(p).size >= 100;
+    }
+    catch {
+        return false;
+    }
+}
 function getDbPath() {
-    return join(getProjectCwd(), '.monomind', 'monograph.db');
+    if (_cachedDbPath !== undefined)
+        return _cachedDbPath ?? join(getProjectCwd(), '.monomind', 'monograph.db');
+    const direct = join(getProjectCwd(), '.monomind', 'monograph.db');
+    if (_isValidDb(direct)) {
+        _cachedDbPath = direct;
+        return direct;
+    }
+    try {
+        const root = execSync('git rev-parse --show-toplevel', { cwd: getProjectCwd(), encoding: 'utf8' }).trim();
+        const candidate = join(root, '.monomind', 'monograph.db');
+        if (_isValidDb(candidate)) {
+            _cachedDbPath = candidate;
+            return candidate;
+        }
+    }
+    catch { /* not in a git repo */ }
+    _cachedDbPath = null;
+    return direct;
 }
 function text(t) {
     return { content: [{ type: 'text', text: t }] };

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

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