monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.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/packages/@monomind/cli/.claude/skills/mastermind/worktree.md

@@ -0,0 +1,215 @@
+---
+name: mastermind-worktree
+description: Use when starting feature work that needs isolation from the current workspace or before executing implementation plans — ensures an isolated workspace exists via native tools or git worktree fallback
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Ensure work happens in an isolated workspace. Prefer the platform's native worktree tools. Fall back to manual git worktrees only when no native tool is available.
+
+**Core principle:** Detect existing isolation first. Then use native tools. Then fall back to git. Never fight the harness.
+
+**Announce at start:** "I'm using the mastermind:worktree skill to set up an isolated workspace."
+
+## Step 0: Detect Existing Isolation
+
+**Before creating anything, check if you are already in an isolated workspace.**
+
+```bash
+GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
+GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
+BRANCH=$(git branch --show-current)
+```
+
+**Submodule guard:** `GIT_DIR != GIT_COMMON` is also true inside git submodules. Before concluding "already in a worktree," verify you are not in a submodule:
+
+```bash
+# If this returns a path, you're in a submodule, not a worktree — treat as normal repo
+git rev-parse --show-superproject-working-tree 2>/dev/null
+```
+
+**If `GIT_DIR != GIT_COMMON` (and not a submodule):** You are already in a linked worktree. Skip to Step 3 (Project Setup). Do NOT create another worktree.
+
+Report with branch state:
+- On a branch: "Already in isolated workspace at `<path>` on branch `<name>`."
+- Detached HEAD: "Already in isolated workspace at `<path>` (detached HEAD, externally managed). Branch creation needed at finish time."
+
+**If `GIT_DIR == GIT_COMMON` (or in a submodule):** You are in a normal repo checkout.
+
+Has the user already indicated their worktree preference? If not, ask for consent before creating a worktree:
+
+> "Would you like me to set up an isolated worktree? It protects your current branch from changes."
+
+Honor any existing declared preference without asking. If the user declines consent, work in place and skip to Step 3.
+
+## Step 1: Create Isolated Workspace
+
+**You have two mechanisms. Try them in this order.**
+
+### 1a. Native Worktree Tools (preferred)
+
+The user has asked for an isolated workspace (Step 0 consent). Is there a native tool to create a worktree? It might be a tool with a name like `EnterWorktree`, `WorktreeCreate`, a `/worktree` command, or a `--worktree` flag. If so, use it and skip to Step 3.
+
+Native tools handle directory placement, branch creation, and cleanup automatically. Using `git worktree add` when you have a native tool creates phantom state the harness can't see or manage.
+
+Only proceed to Step 1b if no native worktree tool is available.
+
+### 1b. Git Worktree Fallback
+
+**Only use this if Step 1a does not apply** — no native worktree tool is available. Create a worktree manually using git.
+
+#### Directory Selection
+
+Follow this priority order. Explicit user preference always beats observed filesystem state.
+
+1. **Check your instructions for a declared worktree directory preference.** If the user has already specified one, use it without asking.
+
+2. **Check for an existing project-local worktree directory:**
+   ```bash
+   ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+   ls -d worktrees 2>/dev/null      # Alternative
+   ```
+   If found, use it. If both exist, `.worktrees` wins.
+
+3. **Check for an existing global directory:**
+   ```bash
+   project=$(basename "$(git rev-parse --show-toplevel)")
+   ls -d ~/.config/monomind/worktrees/$project 2>/dev/null
+   ```
+   If found, use it (backward compatibility with legacy global path).
+
+4. **If there is no other guidance available**, default to `.worktrees/` at the project root.
+
+#### Safety Verification (project-local directories only)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:** Add to .gitignore, commit the change, then proceed.
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+Global directories (`~/.config/monomind/worktrees/`) need no verification.
+
+#### Create the Worktree
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+
+# Determine path based on chosen location
+# For project-local: path="$LOCATION/$BRANCH_NAME"
+# For global: path="~/.config/monomind/worktrees/$project/$BRANCH_NAME"
+
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+**Sandbox fallback:** If `git worktree add` fails with a permission error (sandbox denial), tell the user the sandbox blocked worktree creation and you're working in the current directory instead. Then run setup and baseline tests in place.
+
+## Step 3: Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+## Step 4: Verify Clean Baseline
+
+Run tests to ensure workspace starts clean:
+
+```bash
+# Use project-appropriate command
+npm test / cargo test / pytest / go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### Report
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| Already in linked worktree | Skip creation (Step 0) |
+| In a submodule | Treat as normal repo (Step 0 guard) |
+| Native worktree tool available | Use it (Step 1a) |
+| No native tool | Git worktree fallback (Step 1b) |
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check instruction file, then default `.worktrees/` |
+| Global path exists | Use it (backward compat) |
+| Directory not ignored | Add to .gitignore + commit |
+| Permission error on create | Sandbox fallback, work in place |
+| Tests fail during baseline | Report failures + ask |
+| No package.json/Cargo.toml | Skip dependency install |
+
+## Common Mistakes
+
+### Fighting the harness
+
+- **Problem:** Using `git worktree add` when the platform already provides isolation
+- **Fix:** Step 0 detects existing isolation. Step 1a defers to native tools.
+
+### Skipping detection
+
+- **Problem:** Creating a nested worktree inside an existing one
+- **Fix:** Always run Step 0 before creating anything
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > global legacy > instruction file > default
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+## Red Flags
+
+**Never:**
+- Create a worktree when Step 0 detects existing isolation
+- Use `git worktree add` when you have a native worktree tool (e.g., `EnterWorktree`). This is the #1 mistake — if you have it, use it.
+- Skip Step 1a by jumping straight to Step 1b's git commands
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+
+**Always:**
+- Run Step 0 detection first
+- Prefer native tools over git fallback
+- Follow directory priority: existing > global legacy > instruction file > default
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline