@monoes/monomindcli 1.9.17 → 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/dist/src/init/executor.js

@@ -181,7 +181,7 @@ const DIRECTORIES = {
  * Execute initialization
  */
 /**
- * Remove legacy ruflo/ruv-swarm configuration from existing project files.
+ * Remove legacy ruv-swarm configuration from existing project files.
  * Safe to call even if no legacy config exists.
  */
 function cleanupLegacyTools(targetDir) {
@@ -224,29 +224,29 @@ function cleanupLegacyTools(targetDir) {
         }
         catch { /* non-fatal */ }
     }
-    // Clean ruflo / ruv-swarm from .claude/settings.json hooks and fix MCP package name
+    // Clean ruv-swarm from .claude/settings.json hooks and fix MCP package name
     const settingsPath = path.join(targetDir, '.claude', 'settings.json');
     if (fs.existsSync(settingsPath)) {
         try {
             const raw = fs.readFileSync(settingsPath, 'utf-8');
             const settings = JSON.parse(raw);
             let settingsChanged = false;
-            if (raw.includes('ruflo') || raw.includes('ruv-swarm')) {
-                // Remove ruflo-referencing hook entries from all hook arrays
+            if (raw.includes('ruv-swarm')) {
+                // Remove legacy ruv-swarm hook entries from all hook arrays
                 const hookKeys = ['PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'SessionStart', 'SessionEnd', 'Stop', 'SubagentStart', 'SubagentStop', 'PreCompact'];
                 for (const key of hookKeys) {
                     if (Array.isArray(settings.hooks?.[key])) {
                         const before = settings.hooks[key].length;
                         settings.hooks[key] = settings.hooks[key].filter((entry) => {
                             const str = JSON.stringify(entry);
-                            return !str.includes('ruflo') && !str.includes('ruv-swarm');
+                            return !str.includes('ruv-swarm');
                         });
                         if (settings.hooks[key].length !== before)
                             settingsChanged = true;
                     }
                 }
                 if (settingsChanged) {
-                    cleaned.push('.claude/settings.json: removed ruflo/ruv-swarm hooks');
+                    cleaned.push('.claude/settings.json: removed ruv-swarm hooks');
                 }
             }
             // Fix wrong MCP package name in mcpServers
@@ -283,7 +283,7 @@ export async function executeInit(options) {
     };
     const targetDir = options.targetDir;
     try {
-        // Remove legacy ruflo/ruv-swarm configs before writing new ones
+        // Remove legacy ruv-swarm configs before writing new ones
         const legacyCleaned = cleanupLegacyTools(targetDir);
         for (const msg of legacyCleaned) {
             result.created.files.push(`[cleaned] ${msg}`);
@@ -620,7 +620,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         settingsUpdated: [],
     };
     try {
-        // Fix legacy ruflo/ruv-swarm configs and old MCP package names
+        // Fix legacy ruv-swarm configs and old MCP package names
         const legacyCleaned = cleanupLegacyTools(targetDir);
         for (const msg of legacyCleaned) {
             result.updated.push(`[cleaned] ${msg}`);