monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/.claude/skills/mastermind-workspaces/SKILL.md

@@ -1,261 +0,0 @@
----
-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 mastermind-protocol/SKILL.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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind-worktree/SKILL.md

@@ -1,215 +0,0 @@
----
-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

package/packages/@monomind/cli/.claude/skills/memory-toolkit/SKILL.md

@@ -1,75 +0,0 @@
----
-name: memory-toolkit
-description: >
-  Use monomind's persistent memory store (LanceDB + pure-JS HNSW) to save,
-  search, list, and retrieve cross-session knowledge — patterns, solutions,
-  decisions. Trigger on "remember this", "store in memory", "search memory",
-  "have we solved this before", "recall past decisions", or before starting
-  work that benefits from prior context (debugging, refactors, repeated tasks).
----
-
-# Memory Toolkit
-
-Monomind ships a persistent, namespaced memory store backed by LanceDB with
-a pure-JS HNSW index for approximate nearest-neighbor vector search. Use it
-to avoid re-solving the same problem twice across sessions.
-
-## Before starting non-trivial work
-
-Search for prior art first:
-
-```bash
-npx monomind memory search --query "[task keywords]" --namespace patterns
-npx monomind memory search --query "[task keywords]" --namespace solutions
-```
-
-## Store data
-
-```bash
-# REQUIRED: --key and --value. OPTIONAL: --namespace (default: "default"), --ttl, --tags
-npx monomind memory store --key "pattern-auth" --value "JWT with refresh tokens" --namespace patterns
-npx monomind memory store --key "bug-fix-123" --value "Fixed null check in parser" --namespace solutions --tags "bugfix,auth"
-```
-
-## Search data (semantic / keyword / hybrid)
-
-```bash
-# REQUIRED: --query. OPTIONAL: --namespace, --limit, --threshold, --type
-npx monomind memory search --query "authentication patterns"
-npx monomind memory search --query "JWT" --type keyword
-npx monomind memory search --query "error handling" --namespace patterns --limit 5
-```
-
-| Search type | Description                  | Best for                  |
-| ----------- | ----------------------------- | -------------------------- |
-| `semantic`  | Vector similarity search       | Concept / meaning matching |
-| `keyword`   | BM25 full-text search          | Exact term matching        |
-| `hybrid`    | Combined semantic + keyword    | General purpose (default)  |
-
-Use `--build-hnsw` before searching large memory stores (1,000+ entries) —
-it builds a pure-JS HNSW index for O(log n) queries instead of O(n) linear
-scan (one-time build cost).
-
-## List and retrieve
-
-```bash
-npx monomind memory list --namespace patterns --limit 10
-npx monomind memory retrieve --key "pattern-auth" --namespace patterns
-```
-
-## MCP equivalents
-
-```javascript
-mcp__monomind__memory_store({ key: "pattern-auth", value: "...", namespace: "patterns" })
-mcp__monomind__memory_search({ query: "authentication patterns", namespace: "default", limit: 10, threshold: 0.7, type: "hybrid" })
-```
-
-## After completing non-trivial work
-
-Store what worked so the next session (or agent) doesn't start from zero:
-
-```bash
-npx monomind memory store --key "[short-name]" --value "[what worked and why]" --namespace patterns
-```
-
-See also: `.claude/commands/memory/memory-search.md` for the full flag reference.