monomind 2.3.2 → 2.3.4

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

@@ -0,0 +1,159 @@
+<!-- LEGACY-ORG-V1 — Start a saved org as a persistent, prompt-orchestrated agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped. Reach it only via /mastermind:runorgv1. -->
+
+> **LEGACY-ORG-V1 (2026-07): superseded by `monomind org run <name>` (SDK org runtime v2), delegated to by default via `/mastermind:runorg`.**
+> This prompt-orchestrated path has no delivery guarantees and no ground-truth event stream.
+> It remains only for orgs not yet migrated. New orgs MUST use the daemon. Reach this legacy path only via `/mastermind:runorgv1`.
+
+**If $ARGUMENTS is empty:** List saved orgs and display the following.
+
+---
+
+**MASTERMIND: RUN ORG**
+
+Running an org starts an autonomous agent organization. There are two modes:
+
+**Persistent org** (no schedule): a boss agent loads the org definition, assigns work to specialists from a shared board, and loops indefinitely. Stop with `/mastermind:stoporg --org <name>`.
+
+**Scheduled org** (created with `--schedule`): sets the org to `active` and runs the first iteration immediately. Subsequent iterations are self-scheduled via ScheduleWakeup. The loop stops cleanly within one interval after `/mastermind:stoporg --org <name>`.
+
+**Your saved orgs:**
+
+```bash
+npx -y monomind@latest org list 2>/dev/null \
+  || ls .monomind/orgs/*.json 2>/dev/null | grep -vE -- '-(state|goals|threads|activity|approvals|members|secrets|budgets|routines|issues|projects|workspaces|worktrees|environments|plugins|adapters|join-requests|bootstrap|project-workspaces|approval-comments|skills)\.json$' | xargs -I{} basename {} .json 2>/dev/null \
+  || echo "(none — run /mastermind:createorg to define one)"
+```
+
+**Usage:**
+
+```
+/mastermind:runorgv1 --org <name>
+
+/mastermind:runorgv1 --org content-team --task "Publish the Q2 product roundup post by Friday"
+
+/mastermind:runorgv1 --org research-pod "Focus this week on competitor pricing changes"
+```
+
+**Options:**
+`--org <name>` — which saved org to start (required; prompted if omitted)
+`--task <task>` — override the org's default goal for this run
+Any remaining text is passed as additional context to the boss agent.
+
+No orgs yet? Run `/mastermind:createorg` to define one.
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+**STEP 0 — Extract loop-control flags (do this FIRST, before any other parsing)**
+
+Scan `$ARGUMENTS` for these flags and store their values. Remove them from the argument string before Step 1:
+
+| Flag | Variable | Default |
+|---|---|---|
+| `--rep <N>` | `current_rep = N` | absent |
+| `--loop <id>` | `LOOP_ID = id` | absent |
+| `--tillend` | `tillend_mode = true` | false |
+| `--maxruns <N>` | `tillend_maxruns = N` | 50 |
+| `--wait <N>` | `wait_seconds = N` | 60 |
+| `--repeat <N>` | `repeat_count = N` | 0 |
+
+⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind-skills:runorgv1") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind-skills:_repeat")` at the end.
+
+---
+
+**STEP 1 — Parse org-specific flags**
+
+From the remaining `$ARGUMENTS` (after loop flags removed in Step 0):
+- `--org <name>` → org_name = <name>
+- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses org's stored goal)
+- Remaining text = additional context passed to the boss agent
+
+If `--org` is not provided, list saved orgs and ask which to run:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null)
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg first."
+  exit 1
+fi
+echo "$orgs"
+```
+Ask: "Which org would you like to start? Available: <list from above>"
+
+Verify the org file exists before proceeding:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+
+Resolve session ID and project root:
+```bash
+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")
+# Reuse the loop's original sessionId for continuation runs (keeps all reps under one session)
+if [ -n "${LOOP_ID:-}" ] && [ -f ".monomind/loops/${LOOP_ID}.json" ]; then
+  session_id=$(jq -r '.sessionId // empty' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null)
+fi
+session_id="${session_id:-mm-$(date -u +%Y%m%dT%H%M%S)}"
+```
+
+Emit `session:start` to dashboard:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Emit `domain:dispatch`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Invoke `Skill("mastermind-skills:runorgv1")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
+
+After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg status "<status>" \
+    --arg proj "$REPO_ROOT" \
+    '{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`.
+
+
+**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
+if [ -n "${LOOP_ID:-}" ]; then
+  LOOP_FILE=".monomind/loops/${LOOP_ID}.json"
+  if [ -f "$LOOP_FILE" ]; then
+    python3 -c "
+import json, sys
+f = sys.argv[1]; org = sys.argv[2]
+d = json.load(open(f))
+if 'orgName' not in d:
+    d['orgName'] = org
+    open(f, 'w').write(json.dumps(d, indent=2))
+" "$LOOP_FILE" "${org_name}" 2>/dev/null || true
+  fi
+fi
+```

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

@@ -66,7 +66,7 @@ Invoke `Skill("mastermind-skills:stoporg")` passing: org_name: `$org_name`, sess
 
 After skill returns: emit `session:complete`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
     --arg session "$session_id" \

package/packages/@monomind/cli/.claude/helpers/control-start.cjs

@@ -172,11 +172,16 @@ async function main() {
     ? [...args, String(DEFAULT_PORT)]
     : [...args, 'ui', '--no-open', '--port', String(DEFAULT_PORT)];
 
+  // The child writes its ACTUAL bound port here — the only identity-proof
+  // signal. An HTTP probe alone can be answered by another project's server
+  // already holding the port (which then leaves control.json lying about
+  // where THIS project's events should go).
+  const BOUND_REPORT = path.join(CWD, '.monomind', `.bound-report-${Date.now()}.json`);
   const child = spawn(cmd, allArgs, {
     detached: true,
     stdio: 'ignore',
     cwd: CWD,
-    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD },
+    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD, MONOMIND_BOUND_REPORT: BOUND_REPORT },
   });
 
   child.unref();
@@ -189,11 +194,20 @@ async function main() {
   // If port 4242 was in use, server.mjs auto-increments (up to +10).
   // Poll a few ports to find where it actually bound and update control.json.
   const http = require('http');
+  // Resolves to the responder's pid (number), null for "answers but pid
+  // unreadable" (auth-walled or old server), or false for "no answer".
   function probePort(p) {
     return new Promise((resolve) => {
       const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
-        res.resume();
-        resolve(res.statusCode < 500);
+        let body = '';
+        res.on('data', (c) => { if (body.length < 4096) body += c; });
+        res.on('end', () => {
+          if (res.statusCode >= 500) return resolve(false);
+          try {
+            const pid = JSON.parse(body).pid;
+            resolve(typeof pid === 'number' ? pid : null);
+          } catch { resolve(null); }
+        });
       });
       req.on('error', () => resolve(false));
       req.on('timeout', () => { req.destroy(); resolve(false); });
@@ -201,20 +215,54 @@ async function main() {
   }
 
   // Give the server up to ~10 s to start, then confirm the actual port.
+  // Identity-first: the child's bound-report file (written by server.mjs) is
+  // authoritative; the HTTP probe only confirms a port when the responder's
+  // pid matches our child. A foreign server answering on DEFAULT_PORT must
+  // NOT be mistaken for ours — that lie misroutes every event emitter in
+  // this project (root cause of orgs running invisibly).
   async function confirmPort() {
+    let sawForeignOnDefault = false;
     for (let attempt = 0; attempt < 20; attempt++) {
       await new Promise(r => setTimeout(r, 500));
+      // 1) Authoritative: child self-reported its bound port
+      try {
+        const rep = JSON.parse(fs.readFileSync(BOUND_REPORT, 'utf8'));
+        if (rep && rep.pid === child.pid && typeof rep.port === 'number') {
+          try { fs.unlinkSync(BOUND_REPORT); } catch { /* ignore */ }
+          if (rep.port !== DEFAULT_PORT) {
+            writeStatus(child.pid, rep.port);
+            process.stdout.write(`[control] server bound to port ${rep.port} (updated control.json)\n`);
+          }
+          return;
+        }
+      } catch { /* not written yet or old server — fall through to probe */ }
+      // 2) Fallback: pid-matched HTTP probe (old servers without report support)
       for (let delta = 0; delta <= 10; delta++) {
         const p = DEFAULT_PORT + delta;
-        if (await probePort(p)) {
+        const responderPid = await probePort(p);
+        if (responderPid === false) continue;
+        if (responderPid === child.pid) {
           if (p !== DEFAULT_PORT) {
             writeStatus(child.pid, p);
             process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
           }
           return;
         }
+        if (p === DEFAULT_PORT && typeof responderPid === 'number') sawForeignOnDefault = true;
+        // pid mismatch or unreadable — not provably ours, keep scanning
       }
     }
+    try { fs.unlinkSync(BOUND_REPORT); } catch { /* ignore */ }
+    if (sawForeignOnDefault) {
+      // Another project's server owns DEFAULT_PORT and our child never proved
+      // its own port — point control.json at the live server instead of lying,
+      // and kill our redundant child.
+      try { process.kill(child.pid, 'SIGTERM'); } catch { /* already gone */ }
+      process.stdout.write(`[control] port ${DEFAULT_PORT} is served by another project's control server — reusing it (killed redundant child)\n`);
+      const foreignPid = await probePort(DEFAULT_PORT);
+      writeStatus(typeof foreignPid === 'number' ? foreignPid : 0, DEFAULT_PORT);
+      return;
+    }
     // Server never became reachable on any expected port — kill the child
     // rather than leave an orphan bound to some port nothing will ever read.
     // The next session-start simply retries.

package/packages/@monomind/cli/.claude/helpers/event-logger.cjs

@@ -66,12 +66,20 @@ function forwardToDashboard(entry) {
     const rawPort = Number(ctrl.port);
     const port = (Number.isInteger(rawPort) && rawPort >= 1024 && rawPort <= 65535) ? rawPort : 4242;
     const body = JSON.stringify({ ...entry, hookCaptured: true });
+    // Ingest is default-deny: attach the dashboard credential (written by
+    // server.mjs next to control.json) or the POST is silently rejected.
+    let authHdr = '';
+    try { authHdr = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf8').trim(); } catch {}
     const req = http.request({
       method: 'POST',
       hostname: 'localhost',
       port,
       path: '/api/mastermind/event',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        ...(authHdr ? { 'x-monomind-token': authHdr } : {}),
+      },
       timeout: 400,
     });
     req.on('error', () => {});

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

@@ -201,12 +201,20 @@ function emitEvent(event) {
       }
       const u = new URL(baseUrl);
       const body = JSON.stringify(event);
+      // Ingest is default-deny: attach the dashboard credential (written by
+      // server.mjs next to control.json) or the POST is silently rejected.
+      let authHdr = '';
+      try { authHdr = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf8').trim(); } catch {}
       const req = http.request({
         hostname: u.hostname,
         port: parseInt(u.port || '4242', 10),
         path: '/api/mastermind/event',
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+          ...(authHdr ? { 'x-monomind-token': authHdr } : {}),
+        },
       }, () => {
         try { fs.unlinkSync(spoolFile); } catch {}
         resolve();

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

@@ -319,32 +319,105 @@ module.exports = {
       // ── Second Brain: per-request knowledge injection ──────────────────
       // When the project has an indexed knowledge base, surface the most
       // relevant excerpts for THIS prompt so Claude has them without having
-      // to decide to call knowledge_search. Keyword-scored over chunks.jsonl
-      // (a hook subprocess can't afford a 1-3s embedding-model load per
-      // prompt; full semantic search stays behind the knowledge_search MCP
-      // tool / `monomind doc search`).
-      // monolean: [keyword-only injection] — upgrade path: warm control-server
-      // endpoint holding the embedding model for semantic per-prompt retrieval.
+      // to decide to call knowledge_search. Semantic-first via the dashboard
+      // server's warm /api/knowledge/search (it holds the local embedding
+      // model hot — a hook subprocess can't afford a 1-3s model load per
+      // prompt); tokenized keyword scoring over chunks.jsonl as the fallback
+      // when the server is down or still warming.
       try {
         var sbPrompt = String(prompt || '');
-        // Skip slash commands and trivial prompts — injection would be noise.
-        if (sbPrompt.length >= 12 && sbPrompt.charAt(0) !== '/') {
+        // Skip slash commands and low-content prompts — injection would be
+        // noise. A prompt earns injection only when it carries at least two
+        // substantive terms ("what is next" / "ok go ahead" / "thanks" carry
+        // zero-to-one and must stay quiet; a real question about the project
+        // clears this easily).
+        var _SB_FILLER = new Set(['what', 'whats', 'is', 'are', 'was', 'were', 'the', 'this', 'that', 'these', 'those',
+          'next', 'now', 'then', 'and', 'but', 'for', 'not', 'you', 'your', 'can', 'could', 'should', 'would', 'will',
+          'lets', 'let', 'make', 'made', 'making', 'please', 'okay', 'yes', 'yeah', 'sure', 'thanks', 'thank',
+          'ahead', 'continue', 'proceed', 'more', 'again', 'how', 'why', 'when', 'where', 'who', 'which',
+          'with', 'about', 'from', 'into', 'onto', 'over', 'under', 'all', 'any', 'some', 'one', 'two', 'just',
+          'like', 'want', 'need', 'get', 'got', 'here', 'there', 'still', 'also', 'too', 'very', 'really',
+          'them', 'they', 'their', 'theirs', 'its', 'our', 'ours', 'him', 'her', 'his', 'hers',
+          'order', 'done', 'doing', 'did', 'does', 'goes', 'going', 'went', 'come', 'came', 'good', 'great', 'nice', 'fine']);
+        var _sbSubstantive = sbPrompt.toLowerCase().split(/[^a-z0-9]+/).filter(function(t) {
+          return t.length >= 3 && !_SB_FILLER.has(t);
+        });
+        if (_sbSubstantive.length >= 2 && sbPrompt.charAt(0) !== '/') {
           var sbKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
           if (fs.existsSync(path.join(sbKnowledgeDir, 'chunks.jsonl'))) {
-            var sbSearch = hCtx._buildKnowledgeSearchFn(sbKnowledgeDir);
-            var sbHits = await hCtx.runWithTimeout(
-              function() { return sbSearch(sbPrompt, { namespace: 'knowledge:shared', limit: 3, minScore: 0.45 }); },
-              'second-brain-inject'
-            );
+            var sbHits = null;
+            var sbMethod = 'keyword';
+
+            // Semantic path: warm control-server endpoint (strictly local traffic;
+            // sbAuth is the local dashboard session value from .monomind, same one
+            // every other hook event POST attaches — not a checked-in secret).
+            try {
+              var sbCtrlUrl = 'http://localhost:4242';
+              try {
+                var sbCtl = JSON.parse(fs.readFileSync(path.join(CWD, '.monomind', 'control.json'), 'utf-8'));
+                if (sbCtl.url) sbCtrlUrl = sbCtl.url;
+              } catch (_) {}
+              var sbAuth = '';
+              try { sbAuth = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf-8').trim(); } catch (_) {}
+              var sbResp = await fetch(sbCtrlUrl + '/api/knowledge/search', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-monomind-token': sbAuth },
+                body: JSON.stringify({ query: sbPrompt, namespace: 'knowledge:shared', limit: 3 }),
+                signal: AbortSignal.timeout(900),
+              });
+              if (sbResp.ok) {
+                var sbData = await sbResp.json();
+                if (sbData && Array.isArray(sbData.results) && sbData.results.length > 0) {
+                  sbHits = sbData.results.map(function(r) { return { key: r.key, value: r.content, score: r.score, metadata: {} }; });
+                  sbMethod = sbData.method === 'semantic' ? 'semantic' : 'keyword';
+                }
+              }
+            } catch (_) { /* server down or warming — fall back below */ }
+
+            if (!sbHits) {
+              var sbSearch = hCtx._buildKnowledgeSearchFn(sbKnowledgeDir);
+              sbHits = await hCtx.runWithTimeout(
+                function() { return sbSearch(sbPrompt, { namespace: 'knowledge:shared', limit: 3, minScore: 0.45 }); },
+                'second-brain-inject'
+              );
+            }
+            // Relevance floor: injecting weak matches pollutes every prompt's
+            // context — below 0.35 the excerpt is more likely noise than help.
+            if (sbHits) sbHits = sbHits.filter(function(h) { return (h.score || 0) >= 0.35; });
+
+            // Telemetry: append one JSONL line per evaluated prompt so the
+            // thresholds above can be tuned from real usage (and misses can
+            // seed the golden-set eval). Prompt text is NOT logged.
+            try {
+              var sbMetricsDir = path.join(CWD, '.monomind', 'metrics');
+              fs.mkdirSync(sbMetricsDir, { recursive: true });
+              var sbMetricsFile = path.join(sbMetricsDir, 'second-brain.jsonl');
+              try {
+                if (fs.existsSync(sbMetricsFile) && fs.statSync(sbMetricsFile).size > 512 * 1024) {
+                  var sbOld = fs.readFileSync(sbMetricsFile, 'utf-8').trim().split('\n');
+                  fs.writeFileSync(sbMetricsFile, sbOld.slice(-500).join('\n') + '\n', 'utf-8');
+                }
+              } catch (_) {}
+              fs.appendFileSync(sbMetricsFile, JSON.stringify({
+                ts: Date.now(),
+                method: sbMethod,
+                hits: sbHits ? sbHits.length : 0,
+                topScore: sbHits && sbHits[0] ? Number((sbHits[0].score || 0).toFixed(3)) : null,
+                promptLen: sbPrompt.length,
+                terms: _sbSubstantive.length,
+                injected: !!(sbHits && sbHits.length > 0),
+              }) + '\n', 'utf-8');
+            } catch (_) { /* telemetry never blocks */ }
+
             if (sbHits && sbHits.length > 0) {
-              var sbLines = ['[SECOND_BRAIN] ' + sbHits.length + ' relevant excerpt(s) from the project knowledge base:'];
+              var sbLines = ['[SECOND_BRAIN] ' + sbHits.length + ' relevant excerpt(s) (' + sbMethod + ') from the project knowledge base:'];
               for (var sbI = 0; sbI < sbHits.length; sbI++) {
                 var sbH = sbHits[sbI];
                 var sbSrc = (sbH.metadata && sbH.metadata.filePath) ? String(sbH.metadata.filePath).split('/').slice(-2).join('/') : sbH.key;
                 var sbText = String(sbH.value || '').replace(/\s+/g, ' ').slice(0, 240);
                 sbLines.push('  • [' + sbSrc + '] ' + sbText);
               }
-              sbLines.push('  (deeper/semantic lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
+              sbLines.push('  (deeper lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
               console.log(sbLines.join('\n'));
             }
           }

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

@@ -358,6 +358,17 @@ module.exports = {
         var _kbLastCheck = 0;
         try { _kbLastCheck = JSON.parse(fs.readFileSync(_kbMarkerPath, 'utf-8')).ts || 0; } catch (_) {}
         if (Date.now() - _kbLastCheck > 30 * 60 * 1000) {
+          // Marker BEFORE the scan (not only when dirty): the 2000-stat walk
+          // itself is what needs rate-limiting — on a clean tree it used to
+          // re-run on every single session start. Fail-closed: skip when the
+          // marker can't be written, so an unwritable disk can't cause
+          // per-session scans either.
+          var _kbMarkerOk = false;
+          try {
+            fs.writeFileSync(_kbMarkerPath, JSON.stringify({ ts: Date.now() }), 'utf-8');
+            _kbMarkerOk = true;
+          } catch (_) {}
+          if (!_kbMarkerOk) throw new Error('reindex marker unwritable — skipping scan');
           // Cheap bounded scan: any document changed since the last ingest?
           var _DOC_EXT = { '.md': 1, '.txt': 1, '.pdf': 1, '.docx': 1 };
           var _kbDirty = false;
@@ -380,24 +391,20 @@ module.exports = {
           };
           _kbWalk(CWD, 0);
           if (_kbDirty) {
-            var _kbMarkerOk = false;
-            try {
-              fs.writeFileSync(_kbMarkerPath, JSON.stringify({ ts: Date.now() }), 'utf-8');
-              _kbMarkerOk = true;
-            } catch (_) {}
-            if (_kbMarkerOk) {
-              var _kbSpawn = require('child_process').spawn;
-              var _kbChild = _kbSpawn('npx', ['-y', 'monomind@latest', 'doc', 'ingest', '.'], {
-                cwd: CWD,
-                detached: true,
-                stdio: 'ignore',
-                env: process.env,
-                shell: process.platform === 'win32',
-                windowsHide: true,
-              });
-              _kbChild.unref();
-              console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
-            }
+            var _kbSpawn = require('child_process').spawn;
+            var _kbChild = _kbSpawn('npx', ['-y', 'monomind@latest', 'doc', 'ingest', '.'], {
+              cwd: CWD,
+              detached: true,
+              stdio: 'ignore',
+              env: process.env,
+              shell: process.platform === 'win32',
+              windowsHide: true,
+            });
+            // Without an error listener, a missing npx binary emits an
+            // unhandled 'error' event and crashes the whole session-start hook.
+            _kbChild.on('error', function () { /* npx unavailable — reindex on a later session */ });
+            _kbChild.unref();
+            console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
           }
         }
       }

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

@@ -230,7 +230,7 @@ Resolve `CTRL_URL` at runtime: `jq -r '.url // "http://localhost:4242"' "$REPO_R
 ```bash
 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 -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
     --arg sid "$SESSION_ID" \

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

@@ -73,7 +73,7 @@ Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment
   ```bash
   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" \
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
     -H "Content-Type: application/json" \
     -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
   ```
@@ -103,7 +103,7 @@ If `current_rep >= repeat_count`:
   ```bash
   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" \
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
     -H "Content-Type: application/json" \
     -d "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
   ```
@@ -151,7 +151,7 @@ Emit `loop:tick`:
 ```bash
 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" \
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -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
 ```

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

@@ -139,7 +139,7 @@ Emit `org:adapter:installed` event:
 ```bash
 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" \
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn --arg org "$org_name" --arg type "$adapter_type" --arg pkg "$package_name" \
     '{type:"org:adapter:installed",org:$org,adapter:$type,package:$pkg,ts:(now*1000|floor)}')" || true

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

@@ -51,12 +51,15 @@ stateFile=".monomind/orgs/${org_name}-state.json"
 
 jq -r '(.roles // [])[] | "• [\(.id)] \(.title)  agent=\(.agent_type)  reports_to=\(.reports_to // "none")"' "$orgFile"
 
+# LEGACY-ORG-V1: the state file's per-agent heartbeat tracking is a v1 concept —
+# v2 orgs report live status via `monomind org status`/`org report` instead.
 # Overlay runtime status from state file if present
 if [ -f "$stateFile" ]; then
   echo ""
   echo "RUNTIME STATUS:"
   jq -r '.agents // {} | to_entries[] | "  \(.key): \(.value.status // "unknown")  last_beat=\(.value.last_heartbeat // "never")"' "$stateFile" 2>/dev/null || true
 fi
+# end LEGACY-ORG-V1
 ```
 
 Render as table:
@@ -126,7 +129,7 @@ Then emit `org:agent:hired` event to dashboard:
 ```bash
 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" \
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn --arg org "$org_name" --arg role "$agent_id" --arg title "$title" \
     '{type:"org:agent:hired",org:$org,role:$role,title:$title,ts:(now*1000|floor)}')" || true
@@ -134,6 +137,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 
 ### pause / resume
 
+<!-- LEGACY-ORG-V1: the agent state/heartbeat file this pauses is a v1 concept. -->
 Update state file:
 
 ```bash
@@ -169,7 +173,7 @@ org: <org_name>
 agents_count: <N>
 ```
 
-Print summary and any suggested next actions (e.g. "Run /mastermind:heartbeat to trigger a manual heartbeat for this agent").
+Print summary and any suggested next actions (e.g. "Run /mastermind:heartbeatv1 to trigger a manual heartbeat for this agent").
 
 ---
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/{approve.md → approvev1.md}

@@ -1,13 +1,16 @@
 ---
-name: mastermind-approve
-description: Mastermind approve — review and action pending approval requests from agents in a running org. Agents can request human approval before proceeding with sensitive actions.
+name: mastermind-approvev1
+description: "LEGACY-ORG-V1 (2026-07): v2 approvals arrive as question events in the dashboard Human Input tab — no skill needed. Mastermind approvev1 — review and action pending approval requests from agents in a running v1 (prompt-orchestrated) org. Agents can request human approval before proceeding with sensitive actions. Reach it only via `/mastermind:approvev1`."
 type: domain-skill
 default_mode: confirm
 ---
 
-# Mastermind Approve
+# Mastermind Approve (v1, legacy)
 
-This skill is invoked by `mastermind:approve` or directly via `/mastermind:approve`.
+> **LEGACY-ORG-V1 — file-based approval queue for prompt-orchestrated v1 orgs. Reach it only via `/mastermind:approvev1`.**
+> v2 approvals arrive as `question` events in the dashboard Human Input tab — there is no v2 approve skill, the dashboard UI is the approval surface. This skill remains only for orgs not yet migrated off the v1 `board_id`/`topology` config shape.
+
+This skill is invoked by `mastermind:approvev1` or directly via `/mastermind:approvev1`.
 
 ---
 
@@ -150,7 +153,7 @@ jq --arg id "$approval_id" \
 
 2. Emit `org:approval:requested` event to dashboard (so the human is notified).
 
-3. Poll for the approval decision — check the approvals file first (authoritative, updated by both the dashboard UI and `/mastermind:approve`), then fall back to memory:
+3. Poll for the approval decision — check the approvals file first (authoritative, updated by both the dashboard UI and `/mastermind:approvev1`), then fall back to memory:
 ```bash
 approvalsFile=".monomind/orgs/${orgName}-approvals.json"
 while true; do