monomind 1.14.4 → 1.14.6

package/.claude/commands/mastermind/approve.md

@@ -73,7 +73,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg org "$org_name" \
-    --arg proj "$(pwd)" \
+    --arg proj "$REPO_ROOT" \
     '{type:"session:start",session:$session,domain:"ops",prompt:("Approve requests for org: "+$org),mode:"confirm",project:$proj,ts:(now*1000|floor)}')" || true
 ```
 

package/.claude/commands/mastermind/createorg.md

@@ -108,7 +108,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
     --arg session "$session_id" \
     --arg prompt "$prompt" \
     --arg mode "$mode" \
-    --arg proj "$(pwd)" \
+    --arg proj "$REPO_ROOT" \
     '{type:"session:start",session:$session,domain:"ops",prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 

package/.claude/commands/mastermind/master.md

@@ -316,7 +316,7 @@ jq -n --arg sid "$SESSION_ID" --arg proj "$project_name" --arg prompt "$resolved
 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" \
   -H "Content-Type: application/json" \
-  -d "$(jq -cn --arg sid "$SESSION_ID" --arg prompt "$resolved_prompt" --arg mode "$mode" --arg proj "$(pwd)" \
+  -d "$(jq -cn --arg sid "$SESSION_ID" --arg prompt "$resolved_prompt" --arg mode "$mode" --arg proj "$REPO_ROOT" \
     '{type:"session:start",session:$sid,prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 

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

@@ -44,7 +44,26 @@ No orgs yet? Run `/mastermind:createorg` to define one.
 
 ---
 
-Parse `$ARGUMENTS` for:
+**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:runorg") → 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:_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
@@ -68,11 +87,15 @@ If the file does not exist, stop and suggest running `/mastermind:createorg --na
 
 Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
 
-Generate a session ID as a real shell variable:
+Resolve session ID and project root:
 ```bash
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
 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:
@@ -82,7 +105,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg org "$org_name" \
-    --arg proj "$(pwd)" \
+    --arg proj "$REPO_ROOT" \
     '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
@@ -93,7 +116,8 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg org "$org_name" \
-    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),ts:(now*1000|floor)}')" || true
+    --arg proj "$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:runorg")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
@@ -105,7 +129,8 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg status "<status>" \
-    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],ts:(now*1000|floor)}')" || true
+    --arg proj "$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`.

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

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

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

@@ -40,7 +40,7 @@ fi
 ```
 Return `status: blocked` with message: "Org '<org_name>' not found. Run /mastermind:createorg to define it."
 
-Validate the config has at minimum: `name`, `goal`, `roles` (non-empty array), `communication`.
+Validate the config has at minimum: `name`, `goal`, `roles` (non-empty array). The `communication` field is optional; fall back to `edges` if absent (both have the same schema: `from`, `to`, `type`).
 
 ---
 
@@ -351,7 +351,7 @@ YOUR TEAM (direct reports):
 ${directReports.map(r => `• ${r.title} (subagent_type="${r.agent_type}") — ${r.responsibilities.join(', ')}`).join('\n')}
 
 FULL COMMUNICATION TOPOLOGY:
-${orgConfig.communication.map(e => `${e.from} → ${e.to} (${e.type})`).join('\n')}
+${(orgConfig.communication || orgConfig.edges || []).map(e => `${e.from} → ${e.to} (${e.type})`).join('\n')}
 
 SHARED INFRASTRUCTURE:
 - Task board (monotask): board_id=<board_id>
@@ -508,9 +508,20 @@ OPERATING LOOP:
             -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
               --arg from "<role_id>" --arg msg "Completed: <one-sentence summary of output>" \
               '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,ts:(now*1000|floor)}')" || true
+          # TOKEN TRACKING — estimate and persist token usage to state.json for the Budgets dashboard:
+          # Count approximate output tokens from your work (1 word ≈ 1.3 tokens):
+          _tok_out=$(echo -n "<paste a representative sample of your final output here>" | wc -w)
+          _tok_out=$(( _tok_out * 13 / 10 ))
+          _tok_in=8000  # fixed estimate for task context
+          stateFile="$REPO_ROOT/.monomind/orgs/${orgName}-state.json"
+          [ -f "$stateFile" ] && jq --arg id "<role_id>" --argjson in $_tok_in --argjson out $_tok_out \
+            '.agents[$id].tokens_in = ((.agents[$id].tokens_in // 0) + $in) | .agents[$id].tokens_out = ((.agents[$id].tokens_out // 0) + $out)' \
+            "$stateFile" > "${stateFile}.tmp" && mv "${stateFile}.tmp" "$stateFile" || true
 
         Fill in the literal values for orgName="${orgName}", runId="${runId}", sessionId="${sessionId}" — embed them
         directly in the prompt string so the specialist doesn't need to resolve them.
+        For token tracking: set _tok_out to the actual word count of your output text (use wc -w on your
+        output), and replace <role_id> with the literal role id string.
 
 5. Collect completed results from memory (search "${memNs}:report:")
 
@@ -526,8 +537,7 @@ OPERATING LOOP:
    jq -cn --arg runId "${runId}" --arg org "${orgName}" --argjson pend "${pending_count:-0}" \
      '{type:"run:cycle:complete",runId:$runId,org:$org,pending:$pend,ts:(now*1000|floor)}' >> "${runFile}" || true
    activityFile=".monomind/orgs/${orgName}-activity.jsonl"
-   jq -cn --arg org "${orgName}" --arg runId "${runId}" --argjson pend "${pending_count:-0}" \
-     '{type:"run:cycle:complete",org:$org,runId:$runId,ts:(now*1000|floor),pending:$pend}' >> "$activityFile" 2>/dev/null || true
+   echo "{\"type\":\"run:cycle:complete\",\"org\":\"${orgName}\",\"runId\":\"${runId}\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"pending\":${pending_count:-0}}" >> "$activityFile" 2>/dev/null || true
 
 8. REQUIRED — emit org:checkpoint with a one-sentence progress summary (include runId):
    curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
@@ -551,24 +561,26 @@ START NOW: resolve CTRL_URL, check for stop signal, assess the board, create ini
 
 ## Step 5 — Emit Boss Online Event
 
-Emit `org:agent:online` for the boss role (team member events are emitted by the boss itself):
+Emit `org:agent:online` for the boss role (team member events are emitted by the boss itself).
+
+**IMPORTANT**: Shell variables do NOT persist across separate Bash tool calls. Read the `ORG_VARS:` line printed in Step 2+3 and substitute each literal value directly into the curl command before running it. Do NOT use `$variableName` syntax — replace each placeholder with its literal string from `ORG_VARS:`.
 
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+# Replace <CTRL_URL>, <sessionId>, <orgName>, <runId>, <bossRole_id>, <bossRole_title>, <bossRole_agent_type>, <REPO_ROOT>
+# with the LITERAL values from the ORG_VARS: line printed in Step 2+3.
+curl -s -X POST "<CTRL_URL>/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
-    --arg session "$sessionId" \
-    --arg org "$orgName" \
-    --arg runId "$runId" \
-    --arg role "$bossRole_id" \
-    --arg title "$bossRole_title" \
-    --arg agent_type "$bossRole_agent_type" \
-    --arg proj "$REPO_ROOT" \
+    --arg session "<sessionId>" \
+    --arg org "<orgName>" \
+    --arg runId "<runId>" \
+    --arg role "<bossRole_id>" \
+    --arg title "<bossRole_title>" \
+    --arg agent_type "<bossRole_agent_type>" \
+    --arg proj "<REPO_ROOT>" \
     '{type:"org:agent:online",session:$session,org:$org,runId:$runId,role:$role,title:$title,agent_type:$agent_type,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-(Use the scalar string variables `$bossRole_id`, `$bossRole_title`, `$bossRole_agent_type` derived by extracting fields from `bossRole` before constructing the curl call. `CTRL_URL`, `MONO_DIR`, and `runId` were resolved in Step 3 — reuse those variables.)
-
 ---
 
 ## Step 6 — Report to User

package/.claude/skills/mastermind/stoporg.md

@@ -108,7 +108,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 
   Current status: stopped
   The loop will exit at its next scheduled wakeup without rescheduling.
-  Loop fully dead within: ≤<poll_interval_minutes> minutes
+  Loop fully dead within: ≤$(jq -r '.loop.poll_interval_minutes // "?"' "$orgFile") minutes
 
   To restart: /mastermind:runorg --org <org_name>
   Status:     /mastermind:orgstatus --org <org_name>

package/README.md

@@ -139,16 +139,6 @@ graph LR
     E["7+ roles"] -->|hierarchical| F["Boss to leads to workers\nmiddle management"]
 ```
 
-### Pre-built org types
-
-| Org | Goal | Roles |
-|---|---|---|
-| `content-team` | 3 posts/week on AI tools | Director · Writer · Reviewer · SEO · Growth |
-| `dev-squad` | Features from design spec | Lead · Architect · Developer · QA |
-| `research-lab` | Weekly competitive intelligence | Director · Researcher · Analyst · Writer |
-| `sales-engine` | ICP research + outreach sequences | Director · Outbound · Email · Researcher |
-| `ops-squad` | 24/7 monitoring + incident response | SRE · Security · Perf · Incident Cmdr |
-
 ### Org management commands
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.14.4",
+  "version": "1.14.6",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -147,4 +147,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/packages/@monomind/cli/README.md

@@ -139,16 +139,6 @@ graph LR
     E["7+ roles"] -->|hierarchical| F["Boss to leads to workers\nmiddle management"]
 ```
 
-### Pre-built org types
-
-| Org | Goal | Roles |
-|---|---|---|
-| `content-team` | 3 posts/week on AI tools | Director · Writer · Reviewer · SEO · Growth |
-| `dev-squad` | Features from design spec | Lead · Architect · Developer · QA |
-| `research-lab` | Weekly competitive intelligence | Director · Researcher · Analyst · Writer |
-| `sales-engine` | ICP research + outreach sequences | Director · Outbound · Email · Researcher |
-| `ops-squad` | 24/7 monitoring + incident response | SRE · Security · Perf · Incident Cmdr |
-
 ### Org management commands
 
 ```bash

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.14.4",
+  "version": "1.14.6",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -104,4 +104,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}