monomind 1.16.6 → 1.16.7

package/packages/@monomind/cli/.claude/skills/mastermind/backup.md

@@ -0,0 +1,197 @@
+---
+name: mastermind-backup
+description: Mastermind backup — create, list, and restore compressed org backups. Archives all org data files (config, goals, routines, approvals, projects, members, issues, workspaces, worktrees, environments, plugins, adapters, threads, budgets, bootstrap, and activity log) into a timestamped tarball.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Backup
+
+This skill is invoked by `mastermind:backup` or directly via `/mastermind:backup`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to back up or restore (optional for `list`; required for `create`/`restore`)
+- `action`: create | list | restore | delete
+- `backup_file`: path to backup archive (required for `restore`/`delete`; auto-selected for `restore` if omitted → latest)
+- `backup_dir`: directory to store backups (default: `.monomind/backups`)
+- `include_state`: whether to include runtime state file (default: false — state is ephemeral)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Ensure Backup Directory
+
+```bash
+backupDir="${backup_dir:-.monomind/backups}"
+mkdir -p "$backupDir"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### create
+
+Create a compressed backup of all org data files:
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org required for create."; exit 1; }
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+timestamp=$(date +%Y%m%d-%H%M%S)
+archiveName="${org_name}-${timestamp}.tar.gz"
+archivePath="${backupDir}/${archiveName}"
+
+# Collect files to back up
+filesToBackup=""
+for suffix in "" "-goals" "-routines" "-approvals" "-projects" "-members" "-issues" "-workspaces" "-worktrees" "-environments" "-plugins" "-adapters" "-threads" "-budgets" "-project-workspaces" "-approval-comments" "-bootstrap" "-secrets"; do
+  f=".monomind/orgs/${org_name}${suffix}.json"
+  [ -f "$f" ] && filesToBackup="$filesToBackup $f"
+done
+
+# Optionally include runtime state
+if [ "${include_state:-false}" = "true" ]; then
+  stateFile=".monomind/orgs/${org_name}-state.json"
+  [ -f "$stateFile" ] && filesToBackup="$filesToBackup $stateFile"
+fi
+
+# Include recent activity (last 500 lines filtered by org)
+eventsFile="data/mastermind-events.jsonl"
+if [ -f "$eventsFile" ]; then
+  tmpEvents=$(mktemp /tmp/backup-events-XXXXXX.jsonl)
+  grep "\"org\":\"${org_name}\"" "$eventsFile" | tail -500 > "$tmpEvents" || true
+  filesToBackup="$filesToBackup $tmpEvents"
+fi
+
+# Create archive
+tar -czf "$archivePath" $filesToBackup 2>/dev/null
+[ -n "$tmpEvents" ] && rm -f "$tmpEvents"
+
+if [ -f "$archivePath" ]; then
+  sizeKb=$(du -k "$archivePath" | awk '{print $1}')
+  echo "Backup created: $archivePath (${sizeKb}KB)"
+  echo "Files included: $(echo $filesToBackup | wc -w | tr -d ' ')"
+else
+  echo "ERROR: Failed to create backup archive."
+  exit 1
+fi
+```
+
+Emit `org:backup:created` 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" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn --arg org "$org_name" --arg file "$archiveName" \
+    '{type:"org:backup:created",org:$org,file:$file,ts:(now*1000|floor)}')" || true
+```
+
+### list
+
+Show all available backups:
+
+```bash
+echo "BACKUPS — ${backup_dir:-.monomind/backups}"
+echo "──────────────────────────────────────────────"
+printf "%-45s %-12s %s\n" "FILE" "SIZE" "ORG"
+echo "──────────────────────────────────────────────"
+
+found=0
+for f in "${backupDir}"/*.tar.gz; do
+  [ -f "$f" ] || continue
+  name=$(basename "$f")
+  sizeKb=$(du -k "$f" | awk '{print $1}')
+  orgPart=$(echo "$name" | sed 's/-[0-9]\{8\}-[0-9]\{6\}\.tar\.gz$//')
+  if [ -z "$org_name" ] || [ "$orgPart" = "$org_name" ]; then
+    printf "%-45s %-12s %s\n" "$name" "${sizeKb}KB" "$orgPart"
+    found=$((found + 1))
+  fi
+done
+
+[ "$found" -eq 0 ] && echo "  No backups found."
+echo ""
+echo "Total: $found backup(s)"
+```
+
+### restore
+
+Restore org data from a backup archive:
+
+```bash
+# Auto-select latest backup if not specified
+if [ -z "$backup_file" ]; then
+  if [ -n "$org_name" ]; then
+    backup_file=$(ls "${backupDir}/${org_name}-"*.tar.gz 2>/dev/null | sort | tail -1)
+  fi
+  [ -z "$backup_file" ] && { echo "ERROR: No backup file found. Pass --backup-file <path>."; exit 1; }
+fi
+
+[ ! -f "$backup_file" ] && { echo "ERROR: Backup file not found: $backup_file"; exit 1; }
+
+echo "Restoring from: $backup_file"
+echo "This will overwrite existing org data. Confirm? (skipped in auto mode)"
+
+# Extract to a temp dir first, then copy
+tmpDir=$(mktemp -d /tmp/mastermind-restore-XXXXXX)
+tar -xzf "$backup_file" -C "$tmpDir" 2>/dev/null
+
+# Move restored files to correct locations
+find "$tmpDir" -name "*.json" | while read -r f; do
+  dest=$(echo "$f" | sed "s|$tmpDir||")
+  destDir=$(dirname "$dest")
+  mkdir -p "$destDir" 2>/dev/null || true
+  cp "$f" "$dest" && echo "  Restored: $dest"
+done
+
+# Handle events file
+find "$tmpDir" -name "*.jsonl" | while read -r f; do
+  dest=$(echo "$f" | sed "s|$tmpDir||")
+  mkdir -p "$(dirname "$dest")" 2>/dev/null || true
+  cat "$f" >> "$dest" && echo "  Appended events from backup"
+done
+
+rm -rf "$tmpDir"
+echo "Restore complete."
+```
+
+### delete
+
+Remove a specific backup archive:
+
+```bash
+[ -z "$backup_file" ] && { echo "ERROR: --backup-file required for delete."; exit 1; }
+[ ! -f "$backup_file" ] && { echo "ERROR: File not found: $backup_file"; exit 1; }
+rm "$backup_file"
+echo "Deleted: $backup_file"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+backup_file: <path if created>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind/bootstrap.md

@@ -0,0 +1,190 @@
+---
+name: mastermind-bootstrap
+description: Mastermind bootstrap — one-time org initialization that primes the CEO/boss agent with org context, goal hierarchy, and a signed invite token. Run after createorg before first runorg.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Bootstrap
+
+This skill is invoked by `mastermind:bootstrap` or directly via `/mastermind:bootstrap`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to bootstrap (required)
+- `action`: init | token | status | reset
+- `boss_role_id`: role ID of the CEO/boss agent (default: auto-detect by `reports_to: null`)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Resolve Org
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found. Run /mastermind:createorg first."; exit 1; }
+
+bootstrapFile=".monomind/orgs/${org_name}-bootstrap.json"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### status (check bootstrap state)
+
+```bash
+if [ -f "$bootstrapFile" ]; then
+  echo "BOOTSTRAP STATUS — ${org_name}"
+  echo "──────────────────────────────────"
+  jq -r '
+    "  State:       \(.state // "unknown")",
+    "  Boss Role:   \(.boss_role_id // "-")",
+    "  Bootstrapped:\(.bootstrapped_at // "never")",
+    "  Token:       \(if .invite_token then (.invite_token | .[0:8]) + "..." else "none" end)",
+    "  Token used:  \(.token_used // false)"
+  ' "$bootstrapFile"
+else
+  echo "Not bootstrapped. Run /mastermind:bootstrap --org ${org_name} --action init"
+fi
+```
+
+### token (generate a fresh invite token)
+
+Generate a signed one-time token the boss agent uses to authenticate its first session:
+
+```bash
+token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+echo "INVITE TOKEN — ${org_name}"
+echo "──────────────────────────────────"
+echo "  Token: $token"
+echo "  Valid until first use."
+echo ""
+
+# Store token in bootstrap file
+[ ! -f "$bootstrapFile" ] && echo '{}' > "$bootstrapFile"
+tmp="${bootstrapFile}.tmp"
+jq --arg token "$token" --arg ts "$ts" \
+  '.invite_token = $token | .token_generated_at = $ts | .token_used = false' \
+  "$bootstrapFile" > "$tmp" && mv "$tmp" "$bootstrapFile"
+echo "Token stored. Include in boss agent prompt as: INVITE_TOKEN=${token}"
+```
+
+### init (full bootstrap)
+
+Initialize org bootstrap: detect boss, generate token, write primer context:
+
+```bash
+# Auto-detect boss (role with no reports_to or reports_to: null)
+if [ -z "$boss_role_id" ]; then
+  boss_role_id=$(jq -r '(.roles // [])[] | select(.reports_to == null or .reports_to == "") | .id' "$orgFile" | head -1)
+fi
+[ -z "$boss_role_id" ] && { echo "ERROR: Could not detect boss role. Pass --boss-role-id <id>."; exit 1; }
+
+bossConfig=$(jq --arg id "$boss_role_id" '(.roles // [])[] | select(.id == $id)' "$orgFile")
+bossTitle=$(echo "$bossConfig" | jq -r '.title // "CEO"')
+orgGoal=$(jq -r '.goal // "No goal set"' "$orgFile")
+orgTopology=$(jq -r '.topology // "hierarchical"' "$orgFile")
+roleCount=$(jq '.roles | length' "$orgFile")
+governance=$(jq -r '.governance.policy // "auto"' "$orgFile")
+
+# Generate invite token
+token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Write bootstrap record
+cat > "$bootstrapFile" <<EOF
+{
+  "org": "${org_name}",
+  "state": "initialized",
+  "boss_role_id": "${boss_role_id}",
+  "boss_title": "${bossTitle}",
+  "org_goal": "${orgGoal}",
+  "topology": "${orgTopology}",
+  "role_count": ${roleCount},
+  "governance": "${governance}",
+  "invite_token": "${token}",
+  "token_used": false,
+  "token_generated_at": "${ts}",
+  "bootstrapped_at": "${ts}"
+}
+EOF
+
+echo "BOOTSTRAP COMPLETE — ${org_name}"
+echo "──────────────────────────────────────────"
+echo "  Boss:       ${bossTitle} (${boss_role_id})"
+echo "  Goal:       ${orgGoal}"
+echo "  Topology:   ${orgTopology}"
+echo "  Agents:     ${roleCount}"
+echo "  Governance: ${governance}"
+echo "  Token:      ${token}"
+echo ""
+echo "CEO PRIMER (include in boss agent prompt):"
+echo "──────────────────────────────────────────"
+cat <<PRIMER
+ORG: ${org_name}
+ROLE: ${bossTitle}
+GOAL: ${orgGoal}
+GOVERNANCE: ${governance}
+INVITE_TOKEN: ${token}
+
+You are the autonomous CEO of org '${org_name}'. Your mission: ${orgGoal}.
+You lead ${roleCount} agents in a ${orgTopology} topology.
+Governance mode: ${governance}. In 'board' or 'strict' mode, pause before high-risk actions and emit approval requests.
+Use your INVITE_TOKEN for your first heartbeat. Token is single-use.
+PRIMER
+```
+
+Emit `org:bootstrap:complete` 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" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn --arg org "$org_name" --arg boss "$boss_role_id" \
+    '{type:"org:bootstrap:complete",org:$org,boss:$boss,ts:(now*1000|floor)}')" || true
+```
+
+### reset
+
+Clear bootstrap state (next init will regenerate token):
+
+```bash
+if [ -f "$bootstrapFile" ]; then
+  rm "$bootstrapFile"
+  echo "Bootstrap state cleared for '${org_name}'. Run --action init to re-bootstrap."
+else
+  echo "No bootstrap file found for '${org_name}'."
+fi
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+boss_role_id: <boss_role_id>
+state: initialized | token | reset
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind/budgets.md

@@ -0,0 +1,237 @@
+---
+name: mastermind-budgets
+description: Mastermind budgets — view, set, and track token/cost budgets for agents and the entire org. Shows current spend vs. limits, alerts on overages, and lets board members adjust per-agent or org-wide budgets. Reads from -budgets.json org state files.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Budgets
+
+This skill is invoked by `mastermind:budgets` or directly via `/mastermind:budgets`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to manage budgets for (required)
+- `action`: show | set | reset | alert
+- `agent_id`: scope to a specific agent (optional — omit for org-wide)
+- `limit_tokens`: token limit to set (for set)
+- `limit_usd`: USD cost limit to set (for set)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Load Org and Budget File
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+budgetsFile=".monomind/orgs/${org_name}-budgets.json"
+stateFile=".monomind/orgs/${org_name}-state.json"
+
+if [ ! -f "$budgetsFile" ]; then
+  echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD"}' > "$budgetsFile"
+fi
+```
+
+---
+
+## Step 2 — Execute Action
+
+### show (default)
+
+```bash
+echo "BUDGETS — $org_name"
+echo "════════════════════════════════════════════════════════"
+
+python3 - "$orgFile" "$budgetsFile" "$stateFile" "${agent_id:-}" <<'PYEOF'
+import json, sys, os
+
+orgData    = json.load(open(sys.argv[1]))
+budgetData = json.load(open(sys.argv[2]))
+statePath  = sys.argv[3]
+agentFilter= sys.argv[4]
+
+# Load heartbeat state for per-agent token usage
+agentTokens = {}
+if os.path.exists(statePath):
+    try:
+        state = json.load(open(statePath))
+        for r in state.get("roles", []):
+            rid = r.get("id","")
+            agentTokens[rid] = {
+                "tokensIn":  r.get("tokens_in", 0),
+                "tokensOut": r.get("tokens_out", 0),
+                "totalCostUsd": r.get("total_cost_usd", 0.0),
+            }
+    except: pass
+
+orgBudget   = budgetData.get("org_budget", {})
+agentBudgets= budgetData.get("agent_budgets", {})
+period      = budgetData.get("period", "monthly")
+
+print(f"  Period: {period}")
+print()
+
+# Org-wide budget
+orgLimitTokens = orgBudget.get("limit_tokens")
+orgLimitUsd    = orgBudget.get("limit_usd")
+orgSpentTokens = sum(v.get("tokensIn",0) + v.get("tokensOut",0) for v in agentTokens.values())
+orgSpentUsd    = sum(v.get("totalCostUsd",0) for v in agentTokens.values())
+
+print("ORG BUDGET")
+print("────────────────────────────────────────────────────────")
+print(f"  Tokens spent:  {orgSpentTokens:>12,}")
+if orgLimitTokens:
+    pct = orgSpentTokens / orgLimitTokens * 100
+    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
+    print(f"  Token limit:   {orgLimitTokens:>12,}  [{bar}] {pct:.1f}%")
+print(f"  Cost (USD):    ${orgSpentUsd:>11.4f}")
+if orgLimitUsd:
+    pct = orgSpentUsd / orgLimitUsd * 100
+    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
+    print(f"  Cost limit:    ${orgLimitUsd:>11.2f}    [{bar}] {pct:.1f}%")
+print()
+
+# Per-agent budgets
+roles = orgData.get("roles", [])
+if agentFilter:
+    roles = [r for r in roles if r.get("id") == agentFilter]
+
+print("AGENT BUDGETS")
+print("────────────────────────────────────────────────────────")
+print(f"  {'AGENT':<28} {'TOKENS IN':<12} {'TOKENS OUT':<12} {'COST USD':<12} {'LIMIT USD'}")
+print("  " + "─" * 82)
+
+for role in roles:
+    rid   = role.get("id","?")
+    title = role.get("title", rid)[:26]
+    tok   = agentTokens.get(rid, {})
+    tIn   = tok.get("tokensIn", 0)
+    tOut  = tok.get("tokensOut", 0)
+    cost  = tok.get("totalCostUsd", 0.0)
+    lim   = agentBudgets.get(rid, {}).get("limit_usd")
+    limStr= f"${lim:.2f}" if lim else "—"
+
+    overBudget = lim and cost > lim
+    flag = " ⚠ OVER" if overBudget else ""
+    print(f"  {title:<28} {tIn:<12,} {tOut:<12,} ${cost:<11.4f} {limStr}{flag}")
+
+if not roles:
+    print("  (no agents)")
+PYEOF
+
+echo ""
+echo "  Set limit: /mastermind:budgets --org $org_name --action set --agent-id <id> --limit-usd 5.00"
+echo "  Reset:     /mastermind:budgets --org $org_name --action reset"
+```
+
+### set
+
+```bash
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+python3 - "$budgetsFile" "${agent_id:-}" "${limit_tokens:-}" "${limit_usd:-}" "$ts" <<'PYEOF'
+import json, sys
+
+path, agentId, limitTok, limitUsd, ts = sys.argv[1:]
+
+data = json.load(open(path))
+
+if agentId:
+    entry = data.setdefault("agent_budgets", {}).setdefault(agentId, {})
+    if limitTok: entry["limit_tokens"] = int(limitTok)
+    if limitUsd:  entry["limit_usd"] = float(limitUsd)
+    entry["updatedAt"] = ts
+    print(f"  Budget set for agent '{agentId}':")
+    if limitTok: print(f"    Token limit: {int(limitTok):,}")
+    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
+else:
+    org = data.setdefault("org_budget", {})
+    if limitTok: org["limit_tokens"] = int(limitTok)
+    if limitUsd:  org["limit_usd"] = float(limitUsd)
+    org["updatedAt"] = ts
+    print(f"  Org-wide budget updated:")
+    if limitTok: print(f"    Token limit: {int(limitTok):,}")
+    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
+
+with open(path, "w") as f:
+    json.dump(data, f, indent=2)
+PYEOF
+```
+
+### reset
+
+```bash
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD","resetAt":"'"$ts"'"}' > "$budgetsFile"
+echo "  Budget counters reset for '$org_name'  ($ts)"
+echo "  Note: resets limit configs too. Re-run --action set to restore limits."
+```
+
+### alert
+
+Check for agents over their budget limits:
+
+```bash
+echo "BUDGET ALERTS — $org_name"
+echo "────────────────────────────────────────────────────────"
+
+python3 - "$orgFile" "$budgetsFile" "$stateFile" <<'PYEOF'
+import json, sys, os
+
+orgData    = json.load(open(sys.argv[1]))
+budgetData = json.load(open(sys.argv[2]))
+statePath  = sys.argv[3]
+
+agentTokens = {}
+if os.path.exists(statePath):
+    try:
+        state = json.load(open(statePath))
+        for r in state.get("roles", []):
+            rid = r.get("id","")
+            agentTokens[rid] = r.get("total_cost_usd", 0.0)
+    except: pass
+
+agentBudgets = budgetData.get("agent_budgets", {})
+alerts = []
+for rid, ab in agentBudgets.items():
+    lim = ab.get("limit_usd")
+    spent = agentTokens.get(rid, 0.0)
+    if lim and spent > lim:
+        alerts.append((rid, spent, lim))
+
+if not alerts:
+    print("  ✓ All agents within budget.")
+else:
+    print(f"  ⚠ {len(alerts)} agent(s) over budget:")
+    for rid, spent, lim in alerts:
+        print(f"    {rid}: spent ${spent:.4f} / limit ${lim:.2f}")
+PYEOF
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org_name: <org_name>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.