monomind 1.18.13 → 1.18.15

package/.claude/commands/mastermind/_repeat.md

@@ -326,12 +326,31 @@ RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloop
 
 After each run in tillend mode, evaluate whether this run produced **zero findings and zero actions**. The loop stops only when a complete round finds nothing new and makes no changes — not when the AI predicts there is nothing left.
 
-**You (the AI running the loop) must now assess your own output from this run.** Answer these two questions:
+<EXTREMELY-IMPORTANT>
+**Anti-premature-stop rules:**
+- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
+- "There's nothing more to find" is a PREDICTION, not an observation. Predictions do not stop loops.
+- You MUST run the git verification command below. If git shows changes, the round is non-empty. Period.
+- Only a round where git shows NO changes AND you confirm zero findings AND zero actions qualifies as empty.
+</EXTREMELY-IMPORTANT>
+
+**Step 4a — Machine verification (REQUIRED — run this command before any self-assessment):**
+
+```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 self-assessment. Skip directly to "Otherwise" below.
+
+**Step 4b — Self-assessment (only if git shows no changes):**
+
+Only if `GIT_CHANGES` was empty, answer these two questions about this run:
 
 1. **Were any findings produced?** — issues found, problems detected, items identified, things flagged, errors reported, tasks discovered, security vulnerabilities found, etc.
-2. **Were any actions taken?** — files edited, code fixed, tasks created, cards moved, commits made, content written, configs changed, etc.
+2. **Were any actions taken?** — tasks created, content written, configs changed — anything not captured by git diff.
 
-**Set `TILLEND_EMPTY=true` only if BOTH answers are "no" — zero findings AND zero actions this round.**
+**Set `TILLEND_EMPTY=true` only if git shows no changes AND BOTH answers are "no".**
 
 **Important:** If this round found things AND fixed them all, `TILLEND_EMPTY=false`. The loop must run once more to verify the fixes didn't introduce new issues. A "clean" prediction after a productive round is not enough — only an actually empty round stops the loop.
 

package/.claude/commands/mastermind/architect.md

@@ -49,4 +49,4 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
 ```
 
-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/.claude/commands/mastermind/autodev.md

@@ -25,4 +25,4 @@ Invoke `Skill("mastermind-skills:autodev")` passing: brain_context, count, newfe
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `autodev`.
 
-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/.claude/commands/mastermind/build.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:build")` passing: brain_context, prompt, projec
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `build`.
 
-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/.claude/commands/mastermind/code-review.md

@@ -311,4 +311,4 @@ If `ALL_HIL` is empty, omit the HIL section and congratulate:
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-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/.claude/commands/mastermind/debug.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:debug")` passing: brain_context, problem_descri
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `debug`.
 
-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/.claude/commands/mastermind/idea.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:idea")` passing: brain_context, prompt, project
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `idea`.
 
-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/.claude/commands/mastermind/improve.md

@@ -339,4 +339,4 @@ Skill("mastermind-skills:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-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/.claude/commands/mastermind/plan.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:plan")` passing: brain_context, params, project
 
 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/.claude/commands/mastermind/research.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:research")` passing: brain_context, prompt, pro
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `research`.
 
-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/.claude/commands/mastermind/review.md

@@ -18,6 +18,17 @@ Default mode for this command: **auto** (unless `--confirm` flag present or inta
 
 Invoke `Skill("mastermind-skills:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
+**After review findings are collected — AUTO-FIX STEP (mode = auto only):**
+
+When `mode = auto` (the default): if the review produced any fixable findings (code issues, bugs, style problems, security vulnerabilities with clear fixes), apply the fixes immediately in this same run. Do not ask the user whether to fix — auto mode means fix without asking. Specifically:
+1. For each fixable finding, edit the file directly to resolve it.
+2. After all fixes are applied, output a summary: `[review] Auto-fixed N issues. Remaining M issues require manual intervention.`
+3. Non-fixable findings (architectural concerns, design questions, trade-off decisions) are reported but not acted on.
+
+When `mode = confirm`: present findings and ask the user which to fix. This is the ONLY mode where asking is appropriate.
+
+**When `--tillend` is active:** auto-fix is especially critical. Without it, the loop finds the same unfixed issues every round and either loops forever or the AI falsely declares an empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
+
 After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.
 
-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/.claude/commands/mastermind/runorg.md

@@ -133,7 +133,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 Follow _protocol.md Brain Write Procedure for domain `ops`.
 
 
-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.
 
 After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
 ```bash

package/.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/.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/.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/.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/.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/.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/.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/.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.18.13",
+  "version": "1.18.15",
   "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/.claude/commands/mastermind/_repeat.md

@@ -326,12 +326,31 @@ RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloop
 
 After each run in tillend mode, evaluate whether this run produced **zero findings and zero actions**. The loop stops only when a complete round finds nothing new and makes no changes — not when the AI predicts there is nothing left.
 
-**You (the AI running the loop) must now assess your own output from this run.** Answer these two questions:
+<EXTREMELY-IMPORTANT>
+**Anti-premature-stop rules:**
+- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
+- "There's nothing more to find" is a PREDICTION, not an observation. Predictions do not stop loops.
+- You MUST run the git verification command below. If git shows changes, the round is non-empty. Period.
+- Only a round where git shows NO changes AND you confirm zero findings AND zero actions qualifies as empty.
+</EXTREMELY-IMPORTANT>
+
+**Step 4a — Machine verification (REQUIRED — run this command before any self-assessment):**
+
+```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 self-assessment. Skip directly to "Otherwise" below.
+
+**Step 4b — Self-assessment (only if git shows no changes):**
+
+Only if `GIT_CHANGES` was empty, answer these two questions about this run:
 
 1. **Were any findings produced?** — issues found, problems detected, items identified, things flagged, errors reported, tasks discovered, security vulnerabilities found, etc.
-2. **Were any actions taken?** — files edited, code fixed, tasks created, cards moved, commits made, content written, configs changed, etc.
+2. **Were any actions taken?** — tasks created, content written, configs changed — anything not captured by git diff.
 
-**Set `TILLEND_EMPTY=true` only if BOTH answers are "no" — zero findings AND zero actions this round.**
+**Set `TILLEND_EMPTY=true` only if git shows no changes AND BOTH answers are "no".**
 
 **Important:** If this round found things AND fixed them all, `TILLEND_EMPTY=false`. The loop must run once more to verify the fixes didn't introduce new issues. A "clean" prediction after a productive round is not enough — only an actually empty round stops the loop.
 

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

@@ -49,4 +49,4 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
 ```
 
-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/autodev.md

@@ -25,4 +25,4 @@ Invoke `Skill("mastermind-skills:autodev")` passing: brain_context, count, newfe
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `autodev`.
 
-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/build.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:build")` passing: brain_context, prompt, projec
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `build`.
 
-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/code-review.md

@@ -311,4 +311,4 @@ If `ALL_HIL` is empty, omit the HIL section and congratulate:
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-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/debug.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:debug")` passing: brain_context, problem_descri
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `debug`.
 
-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/idea.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:idea")` passing: brain_context, prompt, project
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `idea`.
 
-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/improve.md

@@ -339,4 +339,4 @@ Skill("mastermind-skills:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-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/plan.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:plan")` passing: brain_context, params, project
 
 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/research.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:research")` passing: brain_context, prompt, pro
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `research`.
 
-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/review.md

@@ -18,6 +18,17 @@ Default mode for this command: **auto** (unless `--confirm` flag present or inta
 
 Invoke `Skill("mastermind-skills:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
+**After review findings are collected — AUTO-FIX STEP (mode = auto only):**
+
+When `mode = auto` (the default): if the review produced any fixable findings (code issues, bugs, style problems, security vulnerabilities with clear fixes), apply the fixes immediately in this same run. Do not ask the user whether to fix — auto mode means fix without asking. Specifically:
+1. For each fixable finding, edit the file directly to resolve it.
+2. After all fixes are applied, output a summary: `[review] Auto-fixed N issues. Remaining M issues require manual intervention.`
+3. Non-fixable findings (architectural concerns, design questions, trade-off decisions) are reported but not acted on.
+
+When `mode = confirm`: present findings and ask the user which to fix. This is the ONLY mode where asking is appropriate.
+
+**When `--tillend` is active:** auto-fix is especially critical. Without it, the loop finds the same unfixed issues every round and either loops forever or the AI falsely declares an empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
+
 After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.
 
-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/runorg.md

@@ -133,7 +133,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 Follow _protocol.md Brain Write Procedure for domain `ops`.
 
 
-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.
 
 After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
 ```bash