monomind 1.9.16 → 1.10.0

package/.claude/skills/mastermind/routines.md

@@ -0,0 +1,202 @@
+---
+name: mastermind-routines
+description: Mastermind routines — schedule recurring tasks that trigger agent heartbeats on a cron-like schedule within a running org. Configure concurrency policy and catch-up behavior.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Routines
+
+This skill is invoked by `mastermind:routines` or directly via `/mastermind:routines`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block
+- `org_name`: org to manage routines for
+- `action`: list | add | pause | resume | remove | trigger
+- `routine_id`: slug of the routine (for pause/resume/remove/trigger)
+- `routine_name`: display name (for add)
+- `agent_id`: role id of the agent to trigger
+- `schedule`: cron expression (e.g. "0 9 * * 1-5" = weekdays at 9am)
+- `task_title`: task to create on each trigger
+- `context`: optional context passed to agent on each heartbeat
+- `concurrency`: coalesce_if_active | always_enqueue | skip_if_active (default: coalesce_if_active)
+- `catchup`: skip_missed | enqueue_missed_with_cap (default: skip_missed)
+- `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 Routines
+
+Routines are stored in `.monomind/orgs/<org_name>-routines.json`:
+
+```bash
+routinesFile=".monomind/orgs/${org_name}-routines.json"
+[ ! -f "$routinesFile" ] && echo '{"routines":[]}' > "$routinesFile"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+Show all routines with their schedule and status:
+
+```bash
+jq -r '
+  .routines[] |
+  "[\(.id)] \(.name)  agent=\(.agent_id)  schedule=\"\(.schedule)\"  status=\(.status // "active")\n" +
+  "  task: \(.task_title)\n  concurrency: \(.concurrency)  catchup: \(.catchup)\n  last_run: \(.last_run // "never")  next_run: \(.next_run // "unknown")"
+' "$routinesFile" 2>/dev/null || echo "No routines defined."
+```
+
+Render as:
+```
+ROUTINES — org: <org_name>
+──────────────────────────────────────────────────────
+[weekly-report] Weekly Status Report
+  Agent:    boss  |  Schedule: 0 9 * * 1 (Mondays 9am)
+  Status:   active
+  Task:     "Compile weekly progress report from all agents"
+  Concurrency: coalesce_if_active  |  Catchup: skip_missed
+  Last run: 3 days ago  |  Next run: in 4 days
+
+[daily-content] Daily Content Draft
+  Agent:    content-writer  |  Schedule: 0 10 * * 1-5 (weekdays 10am)
+  Status:   active
+  Task:     "Draft one content piece for the content calendar"
+  Concurrency: skip_if_active  |  Catchup: skip_missed
+  Last run: yesterday  |  Next run: tomorrow 10am
+```
+
+### add
+
+Add a new routine and register a ScheduleWakeup via Claude's native scheduler:
+
+```bash
+routine_id=$(echo "$routine_name" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | tr -s '-')
+tmp="${routinesFile}.tmp"
+jq --arg id "$routine_id" \
+   --arg name "$routine_name" \
+   --arg agent "$agent_id" \
+   --arg schedule "$schedule" \
+   --arg task "$task_title" \
+   --arg context "${context:-}" \
+   --arg concurrency "${concurrency:-coalesce_if_active}" \
+   --arg catchup "${catchup:-skip_missed}" \
+   '.routines += [{
+     "id":$id,"name":$name,"agent_id":$agent,"schedule":$schedule,
+     "task_title":$task,"context":$context,"concurrency":$concurrency,
+     "catchup":$catchup,"status":"active","created_at":(now|todate)
+   }]' \
+   "$routinesFile" > "$tmp" && mv "$tmp" "$routinesFile"
+echo "Routine added: $routine_id"
+echo "Schedule: $schedule"
+echo ""
+echo "NOTE: To activate this routine, use ScheduleWakeup with:"
+echo "  prompt: '/mastermind:routines --action trigger --org $org_name --routine-id $routine_id'"
+echo "  delaySeconds: <seconds until next scheduled run>"
+```
+
+After creating, use `ScheduleWakeup` to schedule the first trigger at the appropriate delay based on the cron expression.
+
+### trigger
+
+Manually trigger a routine immediately (same as a scheduled run):
+
+```bash
+routine=$(jq --arg id "$routine_id" '.routines[] | select(.id == $id)' "$routinesFile")
+rt_agent=$(echo "$routine" | jq -r '.agent_id')
+rt_task=$(echo "$routine" | jq -r '.task_title')
+rt_context=$(echo "$routine" | jq -r '.context // ""')
+rt_concurrency=$(echo "$routine" | jq -r '.concurrency')
+
+# Check concurrency policy
+stateFile=".monomind/orgs/${org_name}-state.json"
+agent_status=$(jq -r --arg a "$rt_agent" '.agents[$a].status // "idle"' "$stateFile" 2>/dev/null)
+
+case "$rt_concurrency" in
+  skip_if_active)
+    [ "$agent_status" = "running" ] && { echo "Skipped: agent $rt_agent is already running (skip_if_active policy)"; exit 0; }
+    ;;
+  coalesce_if_active)
+    # Queue at most one pending run
+    ;;
+esac
+```
+
+Then invoke the heartbeat skill logic: create a task card for `rt_task`, trigger the agent heartbeat.
+
+Update routine's `last_run` and schedule next wakeup:
+
+```bash
+tmp="${routinesFile}.tmp"
+jq --arg id "$routine_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+   '.routines = [.routines[] | if .id == $id then .last_run = $ts else . end]' \
+   "$routinesFile" > "$tmp" && mv "$tmp" "$routinesFile"
+```
+
+### pause / resume
+
+```bash
+tmp="${routinesFile}.tmp"
+jq --arg id "$routine_id" --arg status "$action" \
+   '.routines = [.routines[] | if .id == $id then .status = $status else . end]' \
+   "$routinesFile" > "$tmp" && mv "$tmp" "$routinesFile"
+echo "Routine $routine_id set to: $action"
+```
+
+### remove
+
+```bash
+tmp="${routinesFile}.tmp"
+jq --arg id "$routine_id" '.routines = [.routines[] | select(.id != $id)]' \
+   "$routinesFile" > "$tmp" && mv "$tmp" "$routinesFile"
+echo "Routine $routine_id removed."
+```
+
+---
+
+## Concurrency Policies
+
+| Policy | Behavior |
+|--------|----------|
+| `coalesce_if_active` | If a run is already active, keep just one follow-up queued |
+| `always_enqueue` | Queue every trigger, even if routine is already running |
+| `skip_if_active` | Drop new triggers while a run is active |
+
+## Catch-up Policies
+
+| Policy | Behavior |
+|--------|----------|
+| `skip_missed` | Ignore windows missed while paused/down |
+| `enqueue_missed_with_cap` | Catch up missed windows in capped batches |
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+routine_id: <routine_id if applicable>
+routines_count: <N>
+routines_file: .monomind/orgs/<org_name>-routines.json
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

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

@@ -114,14 +114,39 @@ The board and column IDs were written into the org config by `createorg`. If mis
 [ -z "$todo_col" ]  && { echo "ERROR: org config missing todo_col_id — re-run /mastermind:createorg --name ${orgName}."; exit 1; }
 ```
 
-**Create stop-file directory** (boss agent writes here; must exist before it runs):
+**Create stop-file and state directories:**
 ```bash
 mkdir -p .monomind/orgs/.stops
 ```
 
+**Initialize org state file** (tracks per-agent status, heartbeat timestamps, token usage):
+```bash
+stateFile=".monomind/orgs/${orgName}-state.json"
+if [ ! -f "$stateFile" ]; then
+  jq -n \
+    --arg org "$orgName" \
+    --arg runId "$runId" \
+    '{org:$org,run_id:$runId,started_at:(now|todate),agents:{}}' \
+    > "$stateFile"
+else
+  # Update run_id and started_at for this run
+  tmp="${stateFile}.tmp"
+  jq --arg runId "$runId" \
+     '.run_id = $runId | .started_at = (now|todate)' \
+     "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
+fi
+```
+
+**Remove any stale stop file:**
+```bash
+rm -f "$stopFile"
+```
+
 **Emit `org:start` to dashboard:**
 ```bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+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 session "$sessionId" \
@@ -158,7 +183,7 @@ SHARED INFRASTRUCTURE:
 - Task board (monotask): board_id=${board_id}
   Columns: Todo=${todo_col}  Doing=${doing_col}  Done=${done_col}
 - Memory namespace: ${memNs} (use: npx monomind@latest memory store/search --namespace ${memNs})
-- Dashboard events: POST http://localhost:4242/api/mastermind/event via curl (see below)
+- Dashboard events: POST to mastermind control server via curl — see CTRL_URL resolution in DASHBOARD EVENTS section below
 - Session ID for all events: ${sessionId}
 
 TASK BOARD COMMANDS (use these for all task management):
@@ -191,6 +216,42 @@ TASK BOARD COMMANDS (use these for all task management):
   # Complete a task:
   monotask card move ${board_id} $CARD_ID ${done_col}
 
+ORG STATE FILE (update per agent per cycle for dashboard visibility):
+  stateFile=".monomind/orgs/${orgName}-state.json"
+  # Mark agent as running:
+  jq --arg id "<role_id>" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+     '.agents[$id].status = "running" | .agents[$id].last_heartbeat = $ts' \
+     "$stateFile" > "${stateFile}.tmp" && mv "${stateFile}.tmp" "$stateFile"
+  # Mark agent as idle after completing:
+  jq --arg id "<role_id>" \
+     '.agents[$id].status = "idle" | .agents[$id].last_heartbeat_complete = (now|todate)' \
+     "$stateFile" > "${stateFile}.tmp" && mv "${stateFile}.tmp" "$stateFile"
+  # Add token counts when known:
+  jq --arg id "<role_id>" --argjson in <tokens_in> --argjson out <tokens_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"
+
+APPROVAL GATE (when governance.policy is "board" or "strict"):
+  Before any external action (sending emails, posting content, making purchases, modifying infrastructure):
+  approvalsFile=".monomind/orgs/${orgName}-approvals.json"
+  [ ! -f "$approvalsFile" ] && echo '{"approvals":[]}' > "$approvalsFile"
+  approval_id="req-$(date +%s)"
+  jq --arg id "$approval_id" --arg agent "<role_id>" --arg title "<action summary>" \
+     --arg action "<full action description>" --arg risk "medium" \
+     '.approvals += [{"id":$id,"agent_id":$agent,"title":$title,"action":$action,"risk_level":$risk,"status":"pending","requested_at":(now|todate)}]' \
+     "$approvalsFile" > "${approvalsFile}.tmp" && mv "${approvalsFile}.tmp" "$approvalsFile"
+  # Emit approval request event so human sees it in dashboard
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+    -d "$(jq -cn --arg org "${orgName}" --arg id "$approval_id" --arg title "<title>" \
+      '{type:"org:approval:requested",org:$org,approval_id:$id,title:$title,ts:(now*1000|floor)}')" || true
+  # Poll until approved or rejected (max 30 min):
+  for i in $(seq 1 60); do
+    status=$(npx monomind@latest memory search --query "approval:${approval_id}" --namespace "${memNs}" 2>/dev/null | jq -r '.[0].value.status // ""' 2>/dev/null)
+    [ "$status" = "approved" ] && break
+    [ "$status" = "rejected" ] && { echo "Action rejected by governance policy — skip this action"; break; }
+    sleep 30
+  done
+
 STOP DETECTION (check this FIRST in every loop iteration):
   ls ${stopFile} 2>/dev/null && echo STOP_REQUESTED
 If the file exists: emit org:complete event, clean up with "rm -f ${stopFile}", then exit.
@@ -218,7 +279,9 @@ ${orgConfig.roles.filter(r => r.id !== bossRole.id).map(r =>
 ).join('\n')}
 
 DASHBOARD EVENTS — emit via curl (NOT WebFetch — WebFetch does not support POST):
-  curl -s -X POST http://localhost:4242/api/mastermind/event \
+  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 type TYPE --arg session SESSION --arg org ORG '{type:$type,session:$session,org:$org,ts:(now*1000|floor)}')"
 Payloads:
@@ -238,7 +301,9 @@ START NOW: check for stop signal, assess the board, create initial tasks if none
 Emit `org:agent:online` for the boss role (team member events are emitted by the boss itself):
 
 ```bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+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 session "$sessionId" \
@@ -272,10 +337,10 @@ ACTIVE ROLES
 
 BOARD: <orgName>/org-tasks
 MEMORY: org:<orgName>
-DASHBOARD: http://localhost:4242
+DASHBOARD: see .monomind/control.json for URL (default http://localhost:4242)
 
 To stop: click STOP in the dashboard Orgs panel
-         or run: curl -X POST http://localhost:4242/api/orgs/<orgName>/stop
+         or run: CTRL_URL=$(jq -r '.url // "http://localhost:4242"' .monomind/control.json 2>/dev/null || echo "http://localhost:4242"); curl -X POST "${CTRL_URL}/api/orgs/<orgName>/stop"
 ```
 
 ---
@@ -295,8 +360,8 @@ lessons:
   - what_worked: "Boss agent spawned and org loop started"
   - what_didnt: ""
 next_actions:
-  - "Monitor at http://localhost:4242 — Mastermind Orgs panel"
-  - "To stop: click STOP in dashboard or POST to /api/orgs/<orgName>/stop"
+  - "Monitor in Mastermind Orgs panel (CTRL_URL from .monomind/control.json, default http://localhost:4242)"
+  - "To stop: click STOP in dashboard or: CTRL_URL=$(jq -r '.url // \"http://localhost:4242\"' .monomind/control.json); curl -X POST \"${CTRL_URL}/api/orgs/<orgName>/stop\""
 board_url: "monotask://<orgName>/org-tasks"
 run_id: "<runId>"
 ```

package/.claude/skills/mastermind/search.md

@@ -0,0 +1,186 @@
+---
+name: mastermind-search
+description: Mastermind search — fuzzy cross-org search across tasks, goals, agents, approvals, routines, projects, and activity log. Returns ranked results with org context.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Search
+
+This skill is invoked by `mastermind:search` or directly via `/mastermind:search`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `query`: search term (required)
+- `org_name`: filter to a specific org (optional — searches all orgs if omitted)
+- `scope`: all | tasks | goals | agents | approvals | routines | projects | activity (default: all)
+- `limit`: max results per category (default: 10)
+- `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 Orgs
+
+```bash
+if [ -n "$org_name" ]; then
+  orgs="$org_name"
+else
+  orgs=$(ls .monomind/orgs/*.json 2>/dev/null | grep -v '\-state\|-goals\|-routines\|-approvals\|-projects\|-worktrees\|-secrets' | xargs -I{} basename {} .json | sort)
+fi
+[ -z "$orgs" ] && { echo "No orgs found. Run /mastermind:createorg first."; exit 0; }
+```
+
+---
+
+## Step 2 — Search All Scopes
+
+```bash
+query_lower=$(echo "$query" | tr '[:upper:]' '[:lower:]')
+limit="${limit:-10}"
+total_hits=0
+
+echo "SEARCH: \"${query}\""
+echo "════════════════════════════════════════════════"
+echo ""
+
+for org in $orgs; do
+  orgFile=".monomind/orgs/${org}.json"
+  [ ! -f "$orgFile" ] && continue
+
+  org_hits=0
+
+  # ── Agents ────────────────────────────────────────
+  if [ "$scope" = "all" ] || [ "$scope" = "agents" ]; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '.roles[] | select((.id + " " + .title + " " + (.responsibilities // [] | join(" "))) | ascii_downcase | test($q)) |
+       "[AGENT] \(.id): \(.title)  type=\(.agent_type)"' \
+      "$orgFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / agents ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Goals ─────────────────────────────────────────
+  goalsFile=".monomind/orgs/${org}-goals.json"
+  if [ -f "$goalsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "goals" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '.goals[] | select((.title + " " + (.description // "") + " " + (.status // "")) | ascii_downcase | test($q)) |
+       "[GOAL] [\(.id)] \(.title)  status=\(.status // "open")"' \
+      "$goalsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / goals ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Routines ──────────────────────────────────────
+  routinesFile=".monomind/orgs/${org}-routines.json"
+  if [ -f "$routinesFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "routines" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '.routines[] | select((.name + " " + (.description // "") + " " + (.schedule // "")) | ascii_downcase | test($q)) |
+       "[ROUTINE] \(.name)  schedule=\(.schedule // "-")"' \
+      "$routinesFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / routines ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Approvals ─────────────────────────────────────
+  approvalsFile=".monomind/orgs/${org}-approvals.json"
+  if [ -f "$approvalsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "approvals" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '.approvals[] | select((.title + " " + (.action // "") + " " + (.agent_id // "")) | ascii_downcase | test($q)) |
+       "[APPROVAL] [\(.id)] \(.agent_id): \(.title)  status=\(.status)"' \
+      "$approvalsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / approvals ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Projects ──────────────────────────────────────
+  projectsFile=".monomind/orgs/${org}-projects.json"
+  if [ -f "$projectsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "projects" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '.projects[] | select((.name + " " + (.description // "") + " " + (.lead // "")) | ascii_downcase | test($q)) |
+       "[PROJECT] \(.name)  status=\(.status // "active")  lead=\(.lead // "-")"' \
+      "$projectsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / projects ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Activity log ──────────────────────────────────
+  if [ "$scope" = "all" ] || [ "$scope" = "activity" ]; then
+    eventsFile="data/mastermind-events.jsonl"
+    if [ -f "$eventsFile" ]; then
+      hits=$(grep "\"org\":\"$org\"" "$eventsFile" 2>/dev/null | \
+        jq -r --arg q "$query_lower" \
+          'select((tostring | ascii_downcase | test($q))) |
+           "[EVENT] \(.type)  org=\(.org)  \(if .task then "task=\(.task)" elif .role then "role=\(.role)" else "" end)"' \
+        2>/dev/null | tail -"$limit")
+      if [ -n "$hits" ]; then
+        echo "── $org / activity ──"
+        echo "$hits"
+        echo ""
+        org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+      fi
+    fi
+  fi
+
+  total_hits=$((total_hits + org_hits))
+done
+
+if [ "$total_hits" -eq 0 ]; then
+  echo "  No results found for \"${query}\""
+  echo ""
+  echo "  Tips:"
+  echo "  • Try a shorter or more general query"
+  echo "  • Use --scope to narrow: tasks, goals, agents, approvals, routines, projects, activity"
+  echo "  • Use --org to limit to a specific org"
+fi
+
+echo "════════════════════════════════════════════════"
+echo "Found: ${total_hits} result(s)"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+query: <query>
+scope: <scope>
+orgs_searched: <N>
+total_hits: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.