@monoes/monomindcli 1.11.7 → 1.11.9

package/.claude/skills/mastermind/invites.md

@@ -65,9 +65,9 @@ echo "INVITES — org: $org_name"
 echo "────────────────────────────────────────────────────────"
 
 # Active invites (pending in join_requests with type=invite)
-activeInvites=$(jq '[.join_requests[] | select(.type == "invite" and .status == "pending")] | length' "$membersFile")
+activeInvites=$(jq '[(.join_requests // [])[] | select(.type == "invite" and .status == "pending")] | length' "$membersFile")
 totalMembers=$(jq '.members | length' "$membersFile")
-pendingJoins=$(jq '[.join_requests[] | select(.type != "invite" and .status == "pending_approval")] | length' "$membersFile")
+pendingJoins=$(jq '[(.join_requests // [])[] | select(.type != "invite" and .status == "pending_approval")] | length' "$membersFile")
 
 echo "  Members:          $totalMembers"
 echo "  Pending invites:  $activeInvites"
@@ -78,7 +78,7 @@ if [ "$activeInvites" -gt 0 ]; then
   echo "ACTIVE INVITES"
   printf "  %-28s %-10s %-20s %s\n" "TOKEN" "ROLE" "CREATED" "URL"
   echo "  ────────────────────────────────────────────────────────"
-  jq -r '.join_requests[] | select(.type == "invite" and .status == "pending") |
+  jq -r '(.join_requests // [])[] | select(.type == "invite" and .status == "pending") |
     [.token, (.role // "operator"), (.createdAt // "-"), (.inviteUrl // "-")] | @tsv' \
     "$membersFile" | while IFS=$'\t' read -r tok role ts url; do
     printf "  %-28s %-10s %-20s %s\n" "${tok:0:24}…" "$role" "$ts" "${url:0:40}…"
@@ -126,14 +126,14 @@ echo "To copy URL hint: --action copy-url --invite-id $token"
 
 # Find the invite
 inviteExists=$(jq -r --arg id "$invite_id" \
-  '[.join_requests[] | select((.id == $id or .token == $id) and .type == "invite")] | length' \
+  '[(.join_requests // [])[] | select((.id == $id or .token == $id) and .type == "invite")] | length' \
   "$membersFile")
 [ "$inviteExists" -eq 0 ] && { echo "ERROR: Invite '$invite_id' not found or already resolved."; exit 1; }
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${membersFile}.tmp"
 jq --arg id "$invite_id" --arg ts "$ts" \
-  '.join_requests = [.join_requests[] | if (.id == $id or .token == $id) then
+  '.join_requests = [(.join_requests // [])[] | if (.id == $id or .token == $id) then
      .status = "revoked" | .resolvedAt = $ts
    else . end]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
@@ -148,7 +148,7 @@ echo "  Revoked at: $ts"
 [ -z "$invite_id" ] && { echo "ERROR: --invite-id required."; exit 1; }
 
 inviteUrl=$(jq -r --arg id "$invite_id" \
-  '.join_requests[] | select(.id == $id or .token == $id) | .inviteUrl // ""' \
+  '(.join_requests // [])[] | select(.id == $id or .token == $id) | .inviteUrl // ""' \
   "$membersFile")
 [ -z "$inviteUrl" ] && { echo "ERROR: Invite '$invite_id' not found."; exit 1; }
 
@@ -172,7 +172,7 @@ echo "  Filter: status=$statusFilter  type=$typeFilter"
 echo "────────────────────────────────────────────────────────"
 
 jq -r --arg st "$statusFilter" --arg type "$typeFilter" '
-  .join_requests[] |
+  (.join_requests // [])[] |
   select(
     (.status == $st) and
     (.type != "invite") and
@@ -190,7 +190,7 @@ jq -r --arg st "$statusFilter" --arg type "$typeFilter" '
   echo "  → reject:  --action reject-join  --request-id $id"
 done
 
-total=$(jq --arg st "$statusFilter" '[.join_requests[] | select(.status == $st and .type != "invite")] | length' "$membersFile")
+total=$(jq --arg st "$statusFilter" '[(.join_requests // [])[] | select(.status == $st and .type != "invite")] | length' "$membersFile")
 [ "$total" -eq 0 ] && echo "  No join requests with status='$statusFilter'."
 echo ""
 echo "Total ($statusFilter): $total"
@@ -202,13 +202,13 @@ echo "Total ($statusFilter): $total"
 [ -z "$request_id" ] && { echo "ERROR: --request-id required."; exit 1; }
 
 reqRole=$(jq -r --arg id "$request_id" \
-  '.join_requests[] | select(.id == $id) | .role // "viewer"' "$membersFile")
+  '(.join_requests // [])[] | select(.id == $id) | .role // "viewer"' "$membersFile")
 [ -z "$reqRole" ] && { echo "ERROR: Request '$request_id' not found."; exit 1; }
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${membersFile}.tmp"
 jq --arg id "$request_id" --arg role "$reqRole" --arg ts "$ts" \
-  '.join_requests = [.join_requests[] | if .id == $id then .status = "approved" | .resolvedAt = $ts else . end] |
+  '.join_requests = [(.join_requests // [])[] | if .id == $id then .status = "approved" | .resolvedAt = $ts else . end] |
    .members += [{"id":$id,"role":$role,"status":"active","grants":[],"joinedAt":$ts}]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
 
@@ -222,13 +222,13 @@ echo "  Member added. View members: /mastermind:access --org $org_name --action
 ```bash
 [ -z "$request_id" ] && { echo "ERROR: --request-id required."; exit 1; }
 
-exists=$(jq -r --arg id "$request_id" '[.join_requests[] | select(.id == $id)] | length' "$membersFile")
+exists=$(jq -r --arg id "$request_id" '[(.join_requests // [])[] | select(.id == $id)] | length' "$membersFile")
 [ "$exists" -eq 0 ] && { echo "ERROR: Request '$request_id' not found."; exit 1; }
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${membersFile}.tmp"
 jq --arg id "$request_id" --arg ts "$ts" \
-  '.join_requests = [.join_requests[] | if .id == $id then .status = "rejected" | .resolvedAt = $ts else . end]' \
+  '.join_requests = [(.join_requests // [])[] | if .id == $id then .status = "rejected" | .resolvedAt = $ts else . end]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
 
 echo "Join request '$request_id' rejected."

package/.claude/skills/mastermind/issue-detail.md

@@ -54,7 +54,7 @@ orgFile=".monomind/orgs/${org_name}.json"
 issuesFile=".monomind/orgs/${org_name}-issues.json"
 [ ! -f "$issuesFile" ] && { echo "ERROR: No issues file for org '$org_name'. Create tasks via /mastermind:tasks."; exit 1; }
 
-issueDef=$(jq -r --arg id "$issue_id" '.issues[] | select(.id == $id or .slug == $id)' "$issuesFile")
+issueDef=$(jq -r --arg id "$issue_id" '(.issues // [])[] | select(.id == $id or .slug == $id)' "$issuesFile")
 [ -z "$issueDef" ] && { echo "ERROR: Issue '$issue_id' not found in org '$org_name'."; exit 1; }
 
 resolvedId=$(echo "$issueDef" | jq -r '.id')
@@ -86,7 +86,7 @@ echo "$issueDef" | jq -r '
 '
 
 # Sub-issues
-subCount=$(jq --arg pid "$resolvedId" '[.issues[] | select(.parent_id == $pid)] | length' "$issuesFile" 2>/dev/null || echo 0)
+subCount=$(jq --arg pid "$resolvedId" '[(.issues // [])[] | select(.parent_id == $pid)] | length' "$issuesFile" 2>/dev/null || echo 0)
 echo "  Sub-issues:    $subCount"
 
 # Attachments
@@ -169,7 +169,7 @@ printf "%-24s %-12s %-10s %s\n" "ID" "STATUS" "PRIORITY" "TITLE"
 echo "────────────────────────────────────────────────────────"
 
 count=0
-jq -r --arg pid "$resolvedId" '.issues[] | select(.parent_id == $pid) |
+jq -r --arg pid "$resolvedId" '(.issues // [])[] | select(.parent_id == $pid) |
   [.id, (.status // "open"), (.priority // "medium"), (.title // "(no title)")] | @tsv' \
   "$issuesFile" 2>/dev/null | while IFS=$'\t' read -r id st pri title; do
   printf "%-24s %-12s %-10s %s\n" "$id" "$st" "$pri" "$title"
@@ -215,13 +215,13 @@ echo "  Time: $ts"
 [ -z "$assignee_id" ] && { echo "ERROR: --assignee-id required."; exit 1; }
 
 # Validate agent exists in org
-exists=$(jq --arg id "$assignee_id" '[.roles[] | select(.id == $id)] | length' "$orgFile")
+exists=$(jq --arg id "$assignee_id" '[(.roles // [])[] | select(.id == $id)] | length' "$orgFile")
 [ "$exists" -eq 0 ] && echo "WARNING: Agent '$assignee_id' not found in org '$org_name'. Assigning anyway."
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$resolvedId" --arg ag "$assignee_id" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then .assignee_id = $ag | .updated_at = $ts else . end]' \
+  '.issues = [(.issues // [])[] | if .id == $id then .assignee_id = $ag | .updated_at = $ts else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 
 echo "Issue '$issue_id' assigned to '$assignee_id'."
@@ -233,7 +233,7 @@ echo "Issue '$issue_id' assigned to '$assignee_id'."
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$resolvedId" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then .status = "done" | .updated_at = $ts | .closed_at = $ts else . end]' \
+  '.issues = [(.issues // [])[] | if .id == $id then .status = "done" | .updated_at = $ts | .closed_at = $ts else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 echo "Issue '$issue_id' → done (closed at $ts)."
 ```
@@ -244,7 +244,7 @@ echo "Issue '$issue_id' → done (closed at $ts)."
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$resolvedId" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then .status = "open" | .updated_at = $ts | .closed_at = null else . end]' \
+  '.issues = [(.issues // [])[] | if .id == $id then .status = "open" | .updated_at = $ts | .closed_at = null else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 echo "Issue '$issue_id' → reopened."
 ```
@@ -262,7 +262,7 @@ newStatus=$([ "$recovery_action" = "accept" ] && echo "in_progress" || echo "can
 
 tmp="${issuesFile}.tmp"
 jq --arg id "$resolvedId" --arg st "$newStatus" --arg ts "$ts" --arg ra "$recovery_action" \
-  '.issues = [.issues[] | if .id == $id then
+  '.issues = [(.issues // [])[] | if .id == $id then
      .status = $st | .recovery_status = $ra | .updated_at = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"

package/.claude/skills/mastermind/monitor.md

@@ -59,7 +59,7 @@ for f in "$MONITOR_DIR"/*.json; do
   [ -f "$f" ] || continue
   jq -r '
     "[\(.name)]  status=\(.status // "active")  interval=\(.poll_interval)s  agent=\(.agent_type)
-    sources: \([.sources[].type] | join(", "))
+    sources: \([(.sources // [])[].type] | join(", "))
     last_tick: \(.last_tick // "never")  tasks_done: \(.stats.done // 0)  tasks_failed: \(.stats.failed // 0)"
   ' "$f"
   echo ""
@@ -162,7 +162,7 @@ jq -r '
   "Sources (\(.sources | length)):"
 ' "$cfg"
 
-jq -r '.sources[] | "  [\(.type)] \(.filter | to_entries | map("\(.key)=\(.value)") | join("  "))"' "$cfg"
+jq -r '(.sources // [])[] | "  [\(.type)] \(.filter | to_entries | map("\(.key)=\(.value)") | join("  "))"' "$cfg"
 
 if [ -f "$state_file" ]; then
   in_flight=$(jq '.in_flight // [] | length' "$state_file" 2>/dev/null || echo 0)
@@ -320,7 +320,7 @@ state_file="$MONITOR_DIR/${name}-state.json"
 # Load config
 [ ! -f "$cfg" ] && echo "Monitor '$name' not found — loop terminated." && exit 0
 
-monitor_status=$(jq -r '.status' "$cfg")
+monitor_status=$(jq -r '.status // "active"' "$cfg")
 [ "$monitor_status" = "stopped" ]  && echo "Monitor '$name' stopped — loop terminated." && exit 0
 [ "$monitor_status" = "paused" ]   && echo "Monitor '$name' paused — will not reschedule." && exit 0
 
@@ -353,7 +353,7 @@ If a previous task failed but has retry_count < 3, it remains in `in_flight` wit
 
 ```bash
 retry_task=$(jq -c '
-  .in_flight[] as $t |
+  (.in_flight // [])[] as $t |
   (.processed_ids[($t.source_type + ":" + $t.external_id)].status // "") |
   if . == "retry_pending" then $t else empty end' "$state_file" | head -1)
 ```
@@ -405,7 +405,7 @@ if [ -z "$retry_task" ]; then
         # === Linear adapter (below) ===
 ```
 
-> The `case` block continues through all adapters. After the Filesystem adapter closes its inner loop and `fi`, add `esac` → `done < <(jq -c '.sources[]' "$cfg")` → `fi` (closing the `if [ -z "$retry_task" ]` guard). After the outer `fi`, check `$task_claimed` to decide whether to run the "After claim" section.
+> The `case` block continues through all adapters. After the Filesystem adapter closes its inner loop and `fi`, add `esac` → `done < <(jq -c '(.sources // [])[]' "$cfg")` → `fi` (closing the `if [ -z "$retry_task" ]` guard). After the outer `fi`, check `$task_claimed` to decide whether to run the "After claim" section.
 
 ---
 
@@ -733,7 +733,7 @@ done <<< "$tasks"   # close per-file while loop (reached only if no file was cla
 fi                  # close 'if [ ! -d "$folder" ]' else block
       ;;  # end filesystem case branch
     esac
-  done < <(jq -c '.sources[]' "$cfg")
+  done < <(jq -c '(.sources // [])[]' "$cfg")
 fi  # close 'if [ -z "$retry_task" ]' guard
 # After: if $task_claimed=true, proceed to "After claim"; otherwise skip to Step 5
 ```
@@ -950,7 +950,7 @@ jq --arg key "${task_source_type}:${task_external_id}" \
    --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
    '(.processed_ids[$key].status = "done") |
     (.processed_ids[$key].done_at  = $ts) |
-    (.in_flight = [.in_flight[] | select(.external_id != $eid or .source_type != $stype)])' \
+    (.in_flight = [(.in_flight // [])[] | select(.external_id != $eid or .source_type != $stype)])' \
    "$state_file" > "$tmp" && mv "$tmp" "$state_file"
 
 tmp="${cfg}.tmp"
@@ -991,7 +991,7 @@ if [ "$retry_count" -lt 3 ]; then
      '(.processed_ids[$key].retry_count = $r) |
       (.processed_ids[$key].last_failure = $ts) |
       (.processed_ids[$key].status = "retry_pending") |
-      (.in_flight = [.in_flight[] |
+      (.in_flight = [(.in_flight // [])[] |
         if (.external_id == $eid and .source_type == $stype)
         then .retry_count = $r | .last_failure = $ts
         else . end])' \
@@ -1064,7 +1064,7 @@ Last attempt: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
      --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
      '(.processed_ids[$key].status = "failed") |
       (.processed_ids[$key].failed_at = $ts) |
-      (.in_flight = [.in_flight[] | select(.external_id != $eid or .source_type != $stype)])' \
+      (.in_flight = [(.in_flight // [])[] | select(.external_id != $eid or .source_type != $stype)])' \
      "$state_file" > "$tmp" && mv "$tmp" "$state_file"
 
   tmp="${cfg}.tmp"
@@ -1137,7 +1137,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
     {
       "type": "github",
       "filter": {
-        "repo": "nokhodian/monomind",
+        "repo": "monoes/monomind",
         "assignee": "nokhodian",
         "labels": ["ai-agent"],
         "state": "open",
@@ -1214,7 +1214,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
 ```bash
 # Create a monitor watching GitHub issues assigned to you
 /mastermind:monitor --action start --name dev-watcher \
-  --source github --project nokhodian/monomind --user nokhodian \
+  --source github --project monoes/monomind --user nokhodian \
   --label ai-agent --agent coder --interval 120
 
 # Add a Linear source to an existing monitor

package/.claude/skills/mastermind/my-issues.md

@@ -55,7 +55,7 @@ printf "%-24s %-12s %-10s %s\n" "ID" "STATUS" "PRIORITY" "TITLE"
 echo "────────────────────────────────────────────────────────"
 
 jq -r --arg uid "$assigneeFilter" --arg sf "$statusFilter" '
-  .issues[] |
+  (.issues // [])[] |
   select(
     (.assigneeId == $uid or .assigned_to == $uid) and
     (if $sf == "active" then (.status == "open" or .status == "in_progress")
@@ -69,7 +69,7 @@ jq -r --arg uid "$assigneeFilter" --arg sf "$statusFilter" '
 done
 
 total=$(jq -r --arg uid "$assigneeFilter" \
-  '[.issues[] | select(.assigneeId == $uid or .assigned_to == $uid)] | length' \
+  '[(.issues // [])[] | select(.assigneeId == $uid or .assigned_to == $uid)] | length' \
   "$issuesFile")
 echo ""
 echo "Total assigned: $total"
@@ -81,13 +81,13 @@ echo "Total assigned: $total"
 ```bash
 [ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
 
-exists=$(jq -r --arg id "$issue_id" '[.issues[] | select(.id == $id)] | length' "$issuesFile")
+exists=$(jq -r --arg id "$issue_id" '[(.issues // [])[] | select(.id == $id)] | length' "$issuesFile")
 [ "$exists" -eq 0 ] && { echo "ERROR: Issue '$issue_id' not found."; exit 1; }
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg uid "$assigneeFilter" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then
+  '.issues = [(.issues // [])[] | if .id == $id then
      .assigneeId = $uid | .lastActivityAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
@@ -103,7 +103,7 @@ echo "Issue '$issue_id' assigned to '$assigneeFilter'."
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then
+  '.issues = [(.issues // [])[] | if .id == $id then
      .assigneeId = null | .lastActivityAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
@@ -119,7 +119,7 @@ echo "Issue '$issue_id' unassigned."
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg ts "$ts" \
-  '.issues = [.issues[] | if .id == $id then
+  '.issues = [(.issues // [])[] | if .id == $id then
      .status = "done" | .closedAt = $ts | .lastActivityAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"

package/.claude/skills/mastermind/new-agent.md

@@ -91,7 +91,7 @@ echo "CURRENT ROLES IN ORG: $org_name"
 echo "────────────────────────────────────────────────────────"
 printf "%-22s %-20s %-14s %s\n" "ID" "TITLE" "ADAPTER" "REPORTS TO"
 echo "────────────────────────────────────────────────────────"
-jq -r '.roles[] |
+jq -r '(.roles // [])[] |
   [.id, (.title // "-"), (.adapter.type // "claude-local"), (.reports_to // "(root)")] | @tsv' \
   "$orgFile" | while IFS=$'\t' read -r id title adapter rt; do
   printf "%-22s %-20s %-14s %s\n" "$id" "$title" "$adapter" "$rt"
@@ -165,13 +165,13 @@ if [ -z "$agent_id" ]; then
 fi
 
 # Check for duplicate id
-duplicate=$(jq -r --arg id "$agent_id" '[.roles[] | select(.id == $id)] | length' "$orgFile")
+duplicate=$(jq -r --arg id "$agent_id" '[(.roles // [])[] | select(.id == $id)] | length' "$orgFile")
 [ "$duplicate" -gt 0 ] && { echo "ERROR: Agent id '$agent_id' already exists in org '$org_name'. Use --agent-id to specify a unique id."; exit 1; }
 
 # Validate reports_to if set
 if [ -n "$reports_to" ]; then
-  parentExists=$(jq -r --arg pid "$reports_to" '[.roles[] | select(.id == $pid)] | length' "$orgFile")
-  [ "$parentExists" -eq 0 ] && echo "WARNING: Parent agent '$reports_to' not found in org. Setting anyway."
+  parentExists=$(jq -r --arg pid "$reports_to" '[(.roles // [])[] | select(.id == $pid)] | length' "$orgFile")
+  [ "$parentExists" -eq 0 ] && { echo "ERROR: Parent agent '$reports_to' not found in org '${org_name}'. Check the agent ID with /mastermind:org-chart --org ${org_name}."; exit 1; }
 fi
 
 # Build skills array

package/.claude/skills/mastermind/org-chart.md

@@ -97,9 +97,9 @@ def render(nodes, prefix="", depth=0):
         child_prefix = prefix + ("    " if is_last else "│   ")
         rid = r.get("id", "?")
         title = r.get("title", rid)
-        adapter = r.get("adapter", {})
-        atype = adapter.get("type", "?") if isinstance(adapter, dict) else str(adapter)
+        adapter = r.get("adapter_config", r.get("adapter", {}))
         model = adapter.get("model", "") if isinstance(adapter, dict) else ""
+        atype = model.split("-")[0] if model else "?"
         hb_status = "♡" if rid not in hb or not hb[rid] else "♥"
         gov = r.get("governance") or ""
         gov_str = f" [{gov}]" if gov else ""
@@ -135,7 +135,8 @@ printf "%-24s %-20s %-16s %-20s %s\n" "ID" "TITLE" "ADAPTER" "MODEL" "REPORTS TO
 echo "────────────────────────────────────────────────────────"
 
 echo "$roles" | jq -r '.[] |
-  [.id, (.title // "-"), (.adapter.type // "?"), (.adapter.model // "-"),
+  (((.adapter_config.model // .adapter.model) // "") | split("-") | .[0] | if . == "" then "?" else . end) as $atype |
+  [.id, (.title // "-"), $atype, ((.adapter_config.model // .adapter.model) // "-"),
    (.reports_to // "(root)")] | @tsv' | \
 while IFS=$'\t' read -r id title adapter model rt; do
   printf "%-24s %-20s %-16s %-20s %s\n" "$id" "$title" "$adapter" "$model" "$rt"
@@ -157,13 +158,14 @@ echo "────────────────────────
 
 ql=$(echo "$query" | tr '[:upper:]' '[:lower:]')
 echo "$roles" | jq -r --arg q "$ql" '.[] |
+  (((.adapter_config.model // .adapter.model) // "") | split("-") | .[0] | if . == "" then "?" else . end) as $atype |
   select(
     (.id | ascii_downcase | contains($q)) or
     (.title // "" | ascii_downcase | contains($q)) or
-    (.adapter.type // "" | ascii_downcase | contains($q)) or
-    (.adapter.model // "" | ascii_downcase | contains($q))
+    ((.adapter_config.model // .adapter.model) // "" | ascii_downcase | contains($q)) or
+    (.agent_type // "" | ascii_downcase | contains($q))
   ) |
-  [.id, (.title // "-"), (.adapter.type // "?"), (.reports_to // "(root)")] | @tsv' | \
+  [.id, (.title // "-"), $atype, (.reports_to // "(root)")] | @tsv' | \
 while IFS=$'\t' read -r id title adapter rt; do
   printf "%-24s %-20s %-16s %s\n" "$id" "$title" "$adapter" "$rt"
 done

package/.claude/skills/mastermind/org-settings.md

@@ -75,8 +75,30 @@ tmp="${orgFile}.tmp"
 
 case "$field" in
   name)
+    # Validate new name slug
+    echo "$value" | grep -qE '^[a-z0-9][a-z0-9-]{0,63}$' || { echo "ERROR: name must match ^[a-z0-9][a-z0-9-]{0,63}$"; exit 1; }
+    newOrgFile=".monomind/orgs/${value}.json"
+    [ -f "$newOrgFile" ] && { echo "ERROR: An org named '${value}' already exists."; exit 1; }
+    # Update the name field inside the JSON
     jq --arg v "$value" '.name = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
-    echo "Updated: name → $value"
+    # Rename the main config file
+    mv "$orgFile" "$newOrgFile"
+    # Rename all side-car data files
+    for suffix in -state -goals -routines -approvals -activity -issues -members -projects -workspaces -worktrees -environments -plugins -adapters -threads -budgets -project-workspaces -approval-comments -bootstrap -secrets; do
+      old_file=".monomind/orgs/${org_name}${suffix}.json"
+      [ -f "$old_file" ] && mv "$old_file" ".monomind/orgs/${value}${suffix}.json" || true
+      old_jsonl=".monomind/orgs/${org_name}${suffix}.jsonl"
+      [ -f "$old_jsonl" ] && mv "$old_jsonl" ".monomind/orgs/${value}${suffix}.jsonl" || true
+    done
+    # Rename loop prompt file if present (scheduled orgs)
+    old_loop=".monomind/loops/${org_name}.md"
+    [ -f "$old_loop" ] && mv "$old_loop" ".monomind/loops/${value}.md" || true
+    # Rename stop file if present
+    old_stop=".monomind/orgs/.stops/${org_name}.stop"
+    [ -f "$old_stop" ] && mv "$old_stop" ".monomind/orgs/.stops/${value}.stop" || true
+    echo "Renamed org '${org_name}' → '${value}'"
+    org_name="$value"
+    orgFile="$newOrgFile"
     ;;
   goal)
     jq --arg v "$value" '.goal = $v' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
@@ -143,19 +165,24 @@ mkdir -p ".monomind/exports"
 timestamp=$(date +%Y%m%d-%H%M%S)
 outPath="${export_path:-.monomind/exports/${org_name}-${timestamp}.json}"
 
+# Pre-read optional side-car files (--slurpfile aborts jq when the file is missing)
+goals_json=$([ -f ".monomind/orgs/${org_name}-goals.json" ]    && jq -c '.' ".monomind/orgs/${org_name}-goals.json"    || echo 'null')
+routines_json=$([ -f ".monomind/orgs/${org_name}-routines.json" ] && jq -c '.' ".monomind/orgs/${org_name}-routines.json" || echo 'null')
+projects_json=$([ -f ".monomind/orgs/${org_name}-projects.json" ] && jq -c '.' ".monomind/orgs/${org_name}-projects.json" || echo 'null')
+
 # Merge all org data files into one export bundle
 jq -n \
   --slurpfile config "$orgFile" \
-  --slurpfile goals ".monomind/orgs/${org_name}-goals.json" 2>/dev/null \
-  --slurpfile routines ".monomind/orgs/${org_name}-routines.json" 2>/dev/null \
-  --slurpfile projects ".monomind/orgs/${org_name}-projects.json" 2>/dev/null \
+  --argjson goals     "$goals_json" \
+  --argjson routines  "$routines_json" \
+  --argjson projects  "$projects_json" \
   '{
     exported_at: (now|todate),
     format_version: "1.0",
     config: ($config[0] // {}),
-    goals: ($goals[0].goals // []),
-    routines: ($routines[0].routines // []),
-    projects: ($projects[0].projects // [])
+    goals: ($goals.goals // []),
+    routines: ($routines.routines // []),
+    projects: ($projects.projects // [])
   }' > "$outPath"
 
 echo "Exported: $outPath"
@@ -178,20 +205,30 @@ importedName=$(jq -r '.config.name // .config.org_name // "unnamed"' "$import_pa
 targetOrg="${org_name:-$importedName}"
 mkdir -p ".monomind/orgs"
 
-# Write config
-jq '.config' "$import_path" > ".monomind/orgs/${targetOrg}.json"
-
-# Write goals if present
-goalsData=$(jq '.goals // []' "$import_path")
-[ "$goalsData" != "[]" ] && echo "{\"goals\":$goalsData}" > ".monomind/orgs/${targetOrg}-goals.json"
-
-# Write routines if present
-routinesData=$(jq '.routines // []' "$import_path")
-[ "$routinesData" != "[]" ] && echo "{\"routines\":$routinesData}" > ".monomind/orgs/${targetOrg}-routines.json"
-
-# Write projects if present
-projectsData=$(jq '.projects // []' "$import_path")
-[ "$projectsData" != "[]" ] && echo "{\"projects\":$projectsData}" > ".monomind/orgs/${targetOrg}-projects.json"
+# Write config — update the name field to match targetOrg (in case file was exported under a different name)
+tmpConfig=".monomind/orgs/${targetOrg}.json.tmp"
+jq --arg n "$targetOrg" '.config | .name = $n' "$import_path" > "$tmpConfig" && mv "$tmpConfig" ".monomind/orgs/${targetOrg}.json" || { rm -f "$tmpConfig"; echo "ERROR: Failed to write org config from import."; exit 1; }
+
+# Write goals if present (atomic write)
+goalsData=$(jq -c '.goals // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$goalsData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-goals.json.tmp"
+  jq -n --argjson data "$goalsData" '{"goals":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-goals.json" || rm -f "$tmp"
+fi
+
+# Write routines if present (atomic write)
+routinesData=$(jq -c '.routines // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$routinesData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-routines.json.tmp"
+  jq -n --argjson data "$routinesData" '{"routines":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-routines.json" || rm -f "$tmp"
+fi
+
+# Write projects if present (atomic write)
+projectsData=$(jq -c '.projects // []' "$import_path" 2>/dev/null || echo '[]')
+if [ "$projectsData" != "[]" ]; then
+  tmp=".monomind/orgs/${targetOrg}-projects.json.tmp"
+  jq -n --argjson data "$projectsData" '{"projects":$data}' > "$tmp" && mv "$tmp" ".monomind/orgs/${targetOrg}-projects.json" || rm -f "$tmp"
+fi
 
 echo "Imported org '${targetOrg}' from ${import_path}"
 echo "Agents: $(jq '.config.roles | length' "$import_path")"

package/.claude/skills/mastermind/orgs.md

@@ -0,0 +1,98 @@
+---
+name: mastermind-orgs
+description: Mastermind orgs — list all saved orgs with their status, schedule, and last/next run times. Shows stopped/active/paused state for scheduled orgs.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Orgs
+
+This skill is invoked by `mastermind:orgs` or directly via `/mastermind:orgs`.
+
+Lists all saved orgs from `.monomind/orgs/*.json`.
+
+---
+
+## Inputs
+
+- `caller`: command | master (controls whether brain load runs here)
+
+---
+
+## 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 — List Orgs
+
+```bash
+orgsDir=".monomind/orgs"
+orgFiles=$(ls "$orgsDir"/*.json 2>/dev/null | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments')
+
+if [ -z "$orgFiles" ]; then
+  echo "No saved orgs found."
+  echo "Create one: /mastermind:createorg <goal>"
+  exit 0
+fi
+```
+
+---
+
+## Step 2 — Render Org Table
+
+For each org file (skip state/approvals files), extract and display:
+
+```bash
+echo ""
+printf "%-28s %-10s %-12s %-22s %-22s\n" "ORG" "STATUS" "SCHEDULE" "LAST RUN" "NEXT RUN"
+printf "%-28s %-10s %-12s %-22s %-22s\n" "---" "------" "--------" "--------" "--------"
+
+for f in $orgFiles; do
+  name=$(jq -r '.name // "(unnamed)"' "$f" 2>/dev/null)
+  goal=$(jq -r '.goal // ""' "$f" 2>/dev/null | cut -c1-55)
+  status=$(jq -r '.status // "—"' "$f" 2>/dev/null)
+  interval=$(jq -r 'if .loop.poll_interval_minutes then "\(.loop.poll_interval_minutes)m" else "manual" end' "$f" 2>/dev/null)
+  last_run=$(jq -r '.loop.last_run // "—"' "$f" 2>/dev/null | sed 's/T/ /;s/Z//')
+  next_run=$(jq -r '.loop.next_run // "—"' "$f" 2>/dev/null | sed 's/T/ /;s/Z//')
+  
+  # Status indicator — distinguish non-scheduled (manual) from scheduled loop states
+  if [ "$interval" = "manual" ]; then
+    indicator="■ persistent"
+  else
+    case "$status" in
+      active)  indicator="● active" ;;
+      stopped) indicator="○ stopped" ;;
+      paused)  indicator="⏸ paused" ;;
+      *)       indicator="— unknown" ;;
+    esac
+  fi
+  
+  printf "%-28s %-10s %-12s %-22s %-22s\n" "$name" "$indicator" "$interval" "$last_run" "$next_run"
+  echo "  └ $goal"
+  echo ""
+done
+```
+
+---
+
+## Step 3 — Show Summary and Commands
+
+```
+COMMANDS
+────────
+  /mastermind:orgstatus --org <name>     Detailed status, last runs, activity
+  /mastermind:runorg --org <name>        Start (or restart) a scheduled org
+  /mastermind:stoporg --org <name>       Stop a running scheduled org
+  /mastermind:createorg <goal>           Create a new org
+```
+
+---
+
+## Step 4 — Return Output
+
+```yaml
+domain: ops
+status: complete
+```