monomind 1.9.16 → 1.10.0

package/.claude/skills/mastermind/workspaces.md

@@ -0,0 +1,261 @@
+---
+name: mastermind-workspaces
+description: Mastermind workspaces — manage isolated git worktree workspaces per project. List, attach, detach, stop, and prune workspaces. Grouped by project with running service counts and agent assignments.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Workspaces
+
+This skill is invoked by `mastermind:workspaces` or directly via `/mastermind:workspaces`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to manage workspaces for (required)
+- `action`: list | status | attach | detach | stop | prune
+- `workspace_id`: workspace id (required for status/detach/stop)
+- `project_id`: project to filter by (optional for list)
+- `agent_id`: agent to assign to workspace (required for attach)
+- `worktree_path`: filesystem path of the worktree (required for attach)
+- `caller`: command | master
+
+---
+
+## Workspace Model
+
+A workspace is a git worktree assigned to a project, optionally running services and assigned to an agent.
+
+```json
+{
+  "id": "ws-abc123",
+  "project_id": "project-slug",
+  "agent_id": "backend-dev",
+  "worktree_path": "/tmp/monomind/worktrees/project-slug-abc123",
+  "branch": "feat/my-feature",
+  "status": "active",
+  "services": ["dev-server", "db-watcher"],
+  "createdAt": "2026-01-01T00:00:00Z",
+  "lastActiveAt": "2026-01-02T00:00:00Z"
+}
+```
+
+---
+
+## 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 Workspace Data
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+wsFile=".monomind/orgs/${org_name}-workspaces.json"
+[ ! -f "$wsFile" ] && echo '{"workspaces":[]}' > "$wsFile"
+
+projectsFile=".monomind/orgs/${org_name}-projects.json"
+worktreeRegistry=".monomind/orgs/${org_name}-worktrees.json"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+```bash
+echo "WORKSPACES — org: $org_name"
+[ -n "$project_id" ] && echo "(filtered by project: $project_id)"
+echo "────────────────────────────────────────────────────────"
+
+total=$(jq '.workspaces | length' "$wsFile")
+
+if [ "$total" -eq 0 ]; then
+  echo "  No workspaces. Use --action attach to register one."
+else
+  # Group by project
+  projects=$(jq -r --arg pid "${project_id:-}" '
+    .workspaces |
+    if $pid != "" then map(select(.project_id == $pid)) else . end |
+    [.[].project_id] | unique[]
+  ' "$wsFile")
+
+  while IFS= read -r proj; do
+    [ -z "$proj" ] && continue
+    projName=$([ -f "$projectsFile" ] && jq -r --arg pid "$proj" '.projects[] | select(.id == $pid) | .name // $pid' "$projectsFile" || echo "$proj")
+    echo ""
+    echo "  PROJECT: $projName"
+    echo "  ──────────────────────────────────────────────────"
+    printf "  %-18s %-14s %-18s %-12s %-6s %s\n" "ID" "STATUS" "AGENT" "BRANCH" "SVCS" "PATH"
+
+    jq -r --arg pid "$proj" '.workspaces[] | select(.project_id == $pid) |
+      [.id, (.status // "unknown"), (.agent_id // "(none)"),
+       (.branch // "?"), ((.services // []) | length | tostring),
+       (.worktree_path // "-")]
+      | @tsv' "$wsFile" | while IFS=$'\t' read -r id st ag br svc path; do
+      printf "  %-18s %-14s %-18s %-12s %-6s %s\n" "$id" "$st" "$ag" "$br" "$svc" "$path"
+    done
+  done <<< "$projects"
+fi
+
+echo ""
+echo "Total: $total workspace(s)"
+```
+
+### status
+
+```bash
+[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
+wsDef=$(jq -r --arg id "$workspace_id" '.workspaces[] | select(.id == $id)' "$wsFile")
+[ -z "$wsDef" ] && { echo "ERROR: Workspace '$workspace_id' not found."; exit 1; }
+
+echo "WORKSPACE STATUS — $workspace_id"
+echo "────────────────────────────────────────────────────────"
+echo "$wsDef" | jq -r '
+  "  ID:           \(.id)",
+  "  Project:      \(.project_id // "-")",
+  "  Agent:        \(.agent_id // "(unassigned)")",
+  "  Branch:       \(.branch // "?")",
+  "  Status:       \(.status // "unknown")",
+  "  Created:      \(.createdAt // "-")",
+  "  Last active:  \(.lastActiveAt // "-")",
+  "  Path:         \(.worktree_path // "-")"
+'
+
+# Check if worktree path exists
+path=$(echo "$wsDef" | jq -r '.worktree_path // ""')
+if [ -n "$path" ]; then
+  if [ -d "$path" ]; then
+    echo ""
+    echo "  Worktree: EXISTS at $path"
+    branch=$(git -C "$path" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "?")
+    echo "  Git branch: $branch"
+    dirty=$(git -C "$path" status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+    [ "$dirty" -gt 0 ] && echo "  Uncommitted changes: $dirty file(s)"
+  else
+    echo "  WARNING: Worktree path does not exist: $path"
+  fi
+fi
+
+echo ""
+echo "Services:"
+echo "$wsDef" | jq -r '(.services // [])[] | "  · \(.)"' || echo "  (none)"
+```
+
+### attach
+
+```bash
+[ -z "$project_id" ] && { echo "ERROR: --project-id required."; exit 1; }
+[ -z "$worktree_path" ] && { echo "ERROR: --worktree-path required."; exit 1; }
+
+[ ! -d "$worktree_path" ] && { echo "ERROR: Path does not exist: $worktree_path"; exit 1; }
+
+wsId="ws-$(openssl rand -hex 4 2>/dev/null || python3 -c 'import secrets; print(secrets.token_hex(4))')"
+branch=$(git -C "$worktree_path" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+tmp="${wsFile}.tmp"
+jq --arg id "$wsId" \
+   --arg pid "$project_id" \
+   --arg ag "${agent_id:-}" \
+   --arg path "$worktree_path" \
+   --arg branch "$branch" \
+   --arg ts "$ts" \
+  '.workspaces += [{"id":$id,"project_id":$pid,
+    "agent_id":(if $ag != "" then $ag else null end),
+    "worktree_path":$path,"branch":$branch,
+    "status":"active","services":[],"createdAt":$ts,"lastActiveAt":$ts}]' \
+  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
+
+echo "Workspace attached: $wsId"
+echo "  Project:  $project_id"
+echo "  Agent:    ${agent_id:-(unassigned)}"
+echo "  Branch:   $branch"
+echo "  Path:     $worktree_path"
+```
+
+### detach
+
+```bash
+[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
+tmp="${wsFile}.tmp"
+jq --arg id "$workspace_id" \
+  '.workspaces = [.workspaces[] | if .id == $id then .status = "detached" else . end]' \
+  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
+echo "Workspace '$workspace_id' → detached. The worktree is preserved on disk."
+```
+
+### stop
+
+```bash
+[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
+wsDef=$(jq -r --arg id "$workspace_id" '.workspaces[] | select(.id == $id)' "$wsFile")
+[ -z "$wsDef" ] && { echo "ERROR: Workspace '$workspace_id' not found."; exit 1; }
+
+services=$(echo "$wsDef" | jq -r '(.services // [])[]')
+if [ -n "$services" ]; then
+  echo "Stopping services for workspace $workspace_id…"
+  while IFS= read -r svc; do
+    echo "  Stopping: $svc"
+  done <<< "$services"
+fi
+
+tmp="${wsFile}.tmp"
+jq --arg id "$workspace_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '.workspaces = [.workspaces[] | if .id == $id then .status = "stopped" | .services = [] | .lastActiveAt = $ts else . end]' \
+  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
+
+echo "Workspace '$workspace_id' stopped."
+```
+
+### prune
+
+```bash
+echo "Pruning stopped/detached workspaces for org '$org_name'…"
+
+before=$(jq '.workspaces | length' "$wsFile")
+removed=0
+orphaned=0
+
+tmp="${wsFile}.tmp"
+jq '.workspaces = [.workspaces[] | select(.status != "stopped" and .status != "detached")]' \
+  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
+
+after=$(jq '.workspaces | length' "$wsFile")
+removed=$((before - after))
+
+# Find orphaned worktrees (path gone)
+while IFS= read -r path; do
+  [ -z "$path" ] || [ "$path" = "null" ] && continue
+  [ ! -d "$path" ] && orphaned=$((orphaned + 1))
+done < <(jq -r '.workspaces[].worktree_path // ""' "$wsFile")
+
+echo "  Removed $removed stopped/detached workspace record(s)."
+[ "$orphaned" -gt 0 ] && echo "  WARNING: $orphaned workspace(s) have missing worktree paths. Run --action status to investigate."
+echo "Done. Active workspaces: $(jq '.workspaces | length' "$wsFile")"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+workspace_id: <id if applicable>
+workspaces_total: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/worktree.md

@@ -0,0 +1,187 @@
+---
+name: mastermind-worktree
+description: Mastermind worktree — create isolated git worktrees for org agents. Each agent gets its own branch and working directory, preventing conflicts when multiple agents edit code simultaneously.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Worktree
+
+This skill is invoked by `mastermind:worktree` or directly via `/mastermind:worktree`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block
+- `org_name`: org whose agents need worktrees
+- `action`: list | create | assign | merge | cleanup | status
+- `agent_id`: role id of the agent to create a worktree for
+- `base_branch`: branch to create worktree from (default: current HEAD)
+- `branch_name`: explicit branch name (default: `org/<org_name>/<agent_id>/<YYYYMMDD-HHMMSS>`)
+- `worktree_path`: explicit path (default: `.monomind/worktrees/<org_name>/<agent_id>`)
+- `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`.
+
+---
+
+## Concept
+
+When multiple agents in an org need to edit files concurrently (e.g. a content writer, designer, and developer all working on different parts of a codebase), git worktrees give each agent its own checkout of the repo on a dedicated branch. Changes are isolated until the org's boss (or a human) merges them.
+
+Worktree registry is stored in `.monomind/orgs/<org_name>-worktrees.json`.
+
+---
+
+## Step 1 — Load Worktree Registry
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+worktreesFile=".monomind/orgs/${org_name}-worktrees.json"
+[ ! -f "$worktreesFile" ] && echo '{"worktrees":[]}' > "$worktreesFile"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+```bash
+echo "WORKTREES — org: $org_name"
+echo "──────────────────────────────────────────────"
+git worktree list 2>/dev/null | head -20
+
+echo ""
+echo "REGISTRY:"
+jq -r '.worktrees[] | "[\(.agent_id)] branch=\(.branch)  path=\(.path)  created=\(.created_at)"' \
+   "$worktreesFile" 2>/dev/null || echo "No registered worktrees."
+```
+
+### create
+
+Create a worktree for a specific agent:
+
+```bash
+agentConfig=$(jq --arg id "$agent_id" '.roles[] | select(.id == $id)' "$orgFile")
+[ -z "$agentConfig" ] && { echo "ERROR: Agent '$agent_id' not found in org."; exit 1; }
+
+# Resolve branch name
+timestamp=$(date +%Y%m%d-%H%M%S)
+branch="${branch_name:-org/${org_name}/${agent_id}/${timestamp}}"
+wtPath="${worktree_path:-.monomind/worktrees/${org_name}/${agent_id}}"
+
+# Create the worktree
+git worktree add -b "$branch" "$wtPath" "${base_branch:-HEAD}" 2>&1
+if [ $? -ne 0 ]; then
+  echo "ERROR: Failed to create worktree. Check that git is initialized and the base branch exists."
+  exit 1
+fi
+
+echo "Created worktree: $wtPath (branch: $branch)"
+
+# Register in worktrees file
+tmp="${worktreesFile}.tmp"
+jq --arg agent "$agent_id" \
+   --arg branch "$branch" \
+   --arg path "$wtPath" \
+   --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+   '.worktrees = [.worktrees[] | select(.agent_id != $agent)] +
+    [{"agent_id":$agent,"branch":$branch,"path":$path,"status":"active","created_at":$ts}]' \
+   "$worktreesFile" > "$tmp" && mv "$tmp" "$worktreesFile"
+```
+
+Include worktree path in agent prompt when spawning:
+
+```
+WORKTREE: Your isolated working directory is ${wtPath}
+All file edits should happen inside this directory.
+Branch: ${branch}
+To view your changes: git -C "${wtPath}" diff
+```
+
+### merge
+
+Merge a completed agent's worktree branch back to the base:
+
+```bash
+wt=$(jq --arg id "$agent_id" '.worktrees[] | select(.agent_id == $id)' "$worktreesFile")
+branch=$(echo "$wt" | jq -r '.branch')
+wtPath=$(echo "$wt" | jq -r '.path')
+
+echo "Merging branch $branch..."
+git merge "$branch" --no-ff -m "org($org_name): merge $agent_id work from $branch"
+if [ $? -eq 0 ]; then
+  echo "Merge successful. Removing worktree..."
+  git worktree remove "$wtPath" --force 2>/dev/null || true
+  git branch -d "$branch" 2>/dev/null || true
+  # Update registry
+  tmp="${worktreesFile}.tmp"
+  jq --arg id "$agent_id" \
+     '.worktrees = [.worktrees[] | if .agent_id == $id then .status = "merged" | .merged_at = (now|todate) else . end]' \
+     "$worktreesFile" > "$tmp" && mv "$tmp" "$worktreesFile"
+  echo "Worktree merged and removed."
+else
+  echo "ERROR: Merge conflict on $branch. Resolve manually then run cleanup."
+fi
+```
+
+### status
+
+Show diff summary for all active agent worktrees:
+
+```bash
+jq -r '.worktrees[] | select(.status == "active") | "\(.agent_id) \(.path) \(.branch)"' \
+  "$worktreesFile" | while read -r agent path branch; do
+  echo "[$agent] branch=$branch"
+  git -C "$path" diff --stat 2>/dev/null | tail -3
+  echo ""
+done
+```
+
+### cleanup
+
+Remove all merged or abandoned worktrees:
+
+```bash
+git worktree prune 2>/dev/null
+jq -r '.worktrees[] | select(.status != "active") | .path' "$worktreesFile" | while read -r path; do
+  [ -d "$path" ] && git worktree remove "$path" --force 2>/dev/null || true
+done
+echo "Pruned stale worktrees."
+```
+
+---
+
+## Integration with runorg / heartbeat
+
+When a boss agent assigns code-editing work to an agent, it should:
+
+1. Call `/mastermind:worktree --action create --agent-id <role_id>`
+2. Include the worktree path in the agent's task prompt
+3. When the agent marks the task Done, call `/mastermind:worktree --action merge --agent-id <role_id>`
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+agent_id: <agent_id if applicable>
+branch: <branch if applicable>
+worktree_path: <path if applicable>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2026 ruvnet
+Copyright (c) 2026 monoes
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.9.16",
+  "version": "1.10.0",
   "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",

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.9.16",
+  "version": "1.10.0",
   "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",

package/packages/@monomind/cli/bundled-graph/dist/src/analyze.d.ts

@@ -1,32 +0,0 @@
-import type Graph from 'graphology';
-import type { GodNode, SurpriseEdge, GraphAnalysis, GraphStats, GraphQuestion, GraphDiff, SerializedGraph } from './types.js';
-/**
- * Find the most connected nodes (god nodes) — core abstractions of the codebase.
- * Sorted by total degree (in + out), descending.
- */
-export declare function godNodes(graph: Graph, topN?: number): GodNode[];
-/**
- * Find surprising cross-community connections.
- * An edge is surprising when its endpoints belong to different communities.
- * Base score is degree(source) * degree(target), boosted by confidence and file type factors.
- */
-export declare function surprisingConnections(graph: Graph, topN?: number): SurpriseEdge[];
-/**
- * Compute high-level graph statistics.
- */
-export declare function graphStats(graph: Graph, graphPath?: string): GraphStats;
-/**
- * Build a complete GraphAnalysis object from an annotated graph.
- * Assumes community detection has already been run (nodes have `community` attribute).
- */
-export declare function buildAnalysis(graph: Graph, graphPath?: string): GraphAnalysis;
-/**
- * Generate clarifying questions about uncertain or structurally interesting graph patterns.
- * Sorted by priority (high → medium → low), capped at 25 total.
- */
-export declare function suggestQuestions(graph: Graph, communities?: Record<number, string[]>): GraphQuestion[];
-/**
- * Compute the diff between two serialized graph snapshots.
- */
-export declare function graphDiff(before: SerializedGraph, after: SerializedGraph): GraphDiff;
-//# sourceMappingURL=analyze.d.ts.map

package/packages/@monomind/cli/bundled-graph/dist/src/analyze.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/analyze.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAc,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE1I;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,SAAK,GAAG,OAAO,EAAE,CAkB3D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,SAAK,GAAG,YAAY,EAAE,CAuC7E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAsCvE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAgB7E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,aAAa,EAAE,CAgJtG;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,CAmCpF"}