@monoes/monomindcli 1.9.1 → 1.9.2

package/.claude/commands/mastermind/runorg.md

@@ -78,7 +78,8 @@ curl -s -X POST "http://localhost:4242/api/mastermind/event" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg org "$org_name" \
-    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",ts:(now*1000|floor)}')" || true
+    --arg proj "$(pwd)" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
 Emit `domain:dispatch`:

package/.claude/skills/mastermind/_agent-select.md

@@ -0,0 +1,132 @@
+---
+name: mastermind-agent-select
+description: Shared utility — registry-aware agent selection for mastermind domain skills. Reads .monomind/registry.json and returns ranked agent slugs/names for a given task, prompt, and category filter. Include this logic wherever a domain skill needs to pick the best agent(s) instead of hardcoding types.
+type: helper
+---
+
+# Agent Selection from Registry
+
+Use this pattern whenever a mastermind skill needs to select specialist agents. The registry lives at `.monomind/registry.json` and contains all 257+ available agent types with their category labels.
+
+---
+
+## Standard Selection Block
+
+```bash
+# AGENT SELECTION — pick best agents for the current task
+# Set these before the block:
+#   REGISTRY=".monomind/registry.json"
+#   PROMPT="<the user's prompt or idea description>"
+#   CATEGORIES="marketing strategy product"   # space-separated; adjust per domain
+#   TOP_N=6                                   # how many agents to return
+
+REGISTRY="${REGISTRY:-.monomind/registry.json}"
+
+# 1. Extract candidates from the registry filtered by category
+candidates=$(jq -r \
+  --arg cats "$CATEGORIES" \
+  '[ .agents[]
+     | select(.deprecated != true)
+     | select(
+         .category as $c |
+         ($cats | split(" ") | any(. == $c))
+       )
+     | {name: .name, slug: .slug, category: .category}
+   ] | unique_by(.slug) | .[]' \
+  "$REGISTRY")
+
+# 2. Score each candidate by keyword overlap with the prompt
+# Extract keywords from prompt (words ≥5 chars, lowercase)
+keywords=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')
+
+selected_agents=$(echo "$candidates" | jq -Rs \
+  --arg kw "$keywords" \
+  --argjson n "$TOP_N" \
+  '
+  [ split("\n")[] | select(length > 0) | fromjson ] |
+  map(
+    . as $agent |
+    ($kw | split(" ")) as $keywords |
+    ($agent.name | ascii_downcase) as $name |
+    ($agent.category | ascii_downcase) as $cat |
+    {
+      agent: $agent,
+      score: ([$keywords[] | if (($name | contains(.)) or ($cat | contains(.))) then 1 else 0 end] | add // 0)
+    }
+  ) |
+  sort_by(-.score) |
+  .[0:$n] |
+  map(.agent)
+  ')
+
+echo "$selected_agents"
+```
+
+The output is a JSON array of `{name, slug, category}` objects. Use `.name` as the `subagent_type` in Task calls, `.slug` for display.
+
+---
+
+## Category Map — which categories to filter per domain
+
+| Domain / purpose | Categories to include |
+|---|---|
+| **Idea — user/market angles** | `marketing strategy product academic` |
+| **Idea — technical angles** | `engineering development architecture` |
+| **Idea — ops/business angles** | `sales strategy product project-management` |
+| **Build** | `engineering development architecture devops testing` |
+| **Marketing** | `marketing paid-media strategy` |
+| **Sales** | `sales strategy product` |
+| **Research** | `academic specialized strategy` |
+| **Content** | `marketing specialized` |
+| **Ops** | `project-management strategy support` |
+| **Release** | `devops github engineering` |
+| **Review** | `engineering testing analysis` |
+| **Finance** | `strategy specialized` |
+
+---
+
+## Quick Pattern: pick ONE best agent for a specific task
+
+```bash
+# Pick the single best agent for a task description
+TASK_DESC="<one-line description of what this agent must do>"
+CATS="engineering development"
+
+best_agent=$(jq -r \
+  --arg cats "$CATS" \
+  --arg task "$(echo "$TASK_DESC" | tr '[:upper:]' '[:lower:]')" \
+  '[ .agents[]
+     | select(.deprecated != true)
+     | select(.category as $c | ($cats | split(" ") | any(. == $c)))
+     | {name: .name, slug: .slug,
+        score: (.name | ascii_downcase | if contains($task) then 2 else 0 end)}
+   ]
+   | sort_by(-.score)
+   | .[0].name // "coder"' \
+  "$REGISTRY")
+```
+
+---
+
+## Fallback
+
+If the registry is missing or empty, fall back to these safe defaults per domain:
+
+| Domain | Fallback agents |
+|---|---|
+| idea specialists | `researcher`, `Trend Researcher`, `Growth Hacker` |
+| dev decomp | `Software Architect` |
+| ops decomp | `Product Manager` |
+| build | `coder`, `tester`, `reviewer` |
+| marketing | `Content Creator`, `SEO Specialist` |
+| sales | `Outbound Strategist`, `Deal Strategist` |
+
+---
+
+## Usage in a domain skill
+
+1. Set `REGISTRY`, `PROMPT`, `CATEGORIES`, `TOP_N`
+2. Run the Standard Selection Block
+3. Parse `selected_agents` JSON array
+4. Spawn Task agents using `.name` as `subagent_type`, one per entry
+5. If `selected_agents` is empty or registry missing: use the fallback list above

package/.claude/skills/mastermind/_protocol.md

@@ -137,6 +137,7 @@ Every mastermind run MUST emit structured events to the live dashboard via WebFe
   "session": "<uuid-v4>",
   "prompt": "<resolved user prompt>",
   "mode": "auto|confirm",
+  "project": "<absolute path of current working directory>",
   "ts": 1234567890000
 }
 ```
@@ -212,6 +213,7 @@ WebFetch({
     session: crypto.randomUUID(),   // or generate a timestamp-based ID
     prompt: resolvedPrompt,
     mode: mode,
+    project: process.cwd(),         // REQUIRED: absolute path for multi-project support
     ts: Date.now()
   })
 })
@@ -234,6 +236,61 @@ WebFetch({
 
 ---
 
+## Monotask Space+Board Setup Procedure
+
+**Always follow this exact order — never create a board without first ensuring a space exists.**
+
+Every mastermind run that needs a task board MUST:
+1. Resolve the space (find existing or create new) — space name = `project_name`
+2. Create the board within that space
+3. Link the board to the space immediately after creation
+4. Create columns (Todo → Doing → Done)
+5. Create cards within those columns
+
+If the user is running across multiple repos for the same project, they MUST use the same `project_name` so all boards land in one space.
+
+### Canonical bash block (substitute `<domain>` with: build, marketing, ops, content, etc.)
+
+```bash
+# Step 1 — Resolve space (required; abort if it cannot be created)
+project_name="${project_name:-$(basename "$PWD")}"
+space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+[ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+[ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name' — verify monotask is installed (monotask --version)"; exit 1; }
+
+# Step 2 — Create board
+board_id=$(monotask board create "<domain>" --json | jq -r '.id // empty')
+[ -z "$board_id" ] && { echo "ERROR: Failed to create board '<domain>'"; exit 1; }
+
+# Step 3 — Link board to space immediately
+monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+
+# Step 4 — Create columns
+todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+```
+
+When master.md runs multiple domains, resolve the space **once** before the loop, then repeat steps 2–4 per domain:
+
+```bash
+# Resolve space once
+project_name="<resolved project_name>"
+space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+[ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+[ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+
+# Repeat per active domain (e.g. build, marketing, ops):
+board_<domain>=$(monotask board create "<domain>" --json | jq -r '.id // empty')
+[ -z "$board_<domain>" ] && { echo "ERROR: Failed to create <domain> board"; exit 1; }
+monotask space boards add "$space_id" "$board_<domain>" >/dev/null 2>&1 || true
+todo_<domain>=$(monotask column create "$board_<domain>" "Todo"  --json | jq -r '.id')
+doing_<domain>=$(monotask column create "$board_<domain>" "Doing" --json | jq -r '.id')
+done_<domain>=$(monotask column create "$board_<domain>" "Done"  --json | jq -r '.id')
+```
+
+---
+
 ## Monotask Task Briefing Standard
 
 Every monotask card MUST include ALL fields below in its description and comment. Agents read task cards cold — no back-channel context exists.
@@ -241,8 +298,8 @@ Every monotask card MUST include ALL fields below in its description and comment
 Create each card using `monotask card create`, then populate it. First resolve column IDs:
 ```bash
 columns=$(monotask column list "$BOARD_ID" --json)
-COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Todo" or .name == "Backlog") | .id' | head -1)
-COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Done") | .id' | head -1)
+COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
 ```
 Then create the card:
 ```bash

package/.claude/skills/mastermind/build.md

@@ -46,7 +46,19 @@ If this skill is invoked directly (not by master):
 
 1. Load brain context following _protocol.md Brain Load Procedure (namespace: `build`)
 2. Run intake from _intake.md if prompt is vague
-3. Create or find monotask space `<project_name>`, create board `development`
+3. Follow _protocol.md Monotask Space+Board Setup Procedure:
+   ```bash
+   project_name="${project_name:-$(basename "$PWD")}"
+   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+   board_id=$(monotask board create "development" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create development board"; exit 1; }
+   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+   ```
 4. Proceed with complexity assessment below
 5. At end: follow _protocol.md Brain Write Procedure (namespace: `build`)
 
@@ -80,8 +92,8 @@ STEP 2 — CREATE TASKS
 For each task, create a monotask card on the project board. First look up column IDs and assign shell variables:
 ```bash
 columns=$(monotask column list "$BOARD_ID" --json)
-COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Todo" or .name == "Backlog") | .id' | head -1)
-COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Done") | .id' | head -1)
+COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
 ```
 Then create the card:
 ```bash

package/.claude/skills/mastermind/content.md

@@ -67,7 +67,19 @@ If this skill is invoked directly (not by master):
 
 1. Load brain context following _protocol.md Brain Load Procedure (namespace: `content`)
 2. Run intake from _intake.md if prompt is vague
-3. Create or find monotask space `<project_name>`, create board `content`
+3. Follow _protocol.md Monotask Space+Board Setup Procedure:
+   ```bash
+   project_name="${project_name:-$(basename "$PWD")}"
+   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+   board_id=$(monotask board create "content" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create content board"; exit 1; }
+   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+   ```
 4. Proceed with complexity assessment below
 5. At end: follow _protocol.md Brain Write Procedure (namespace: `content`)
 

package/.claude/skills/mastermind/createorg.md

@@ -225,16 +225,24 @@ jq -n \
   > "${orgJson}.tmp" && mv "${orgJson}.tmp" "$orgJson"
 ```
 
-Create the monotask space, board, and default columns:
+Create the monotask space, board, and default columns (space is required — abort before creating board if space fails):
 ```bash
+# Step 1 — Space (required first)
 space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$org_name" '$2==n{print $1}' | head -1)
 [ -z "$space_id" ] && space_id=$(monotask space create "$org_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
-board_id=$(monotask board create "org-tasks" --json | jq -r '.id')
-[ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board — verify monotask is installed (run: monotask --version)"; exit 1; }
-todo_col_id=$(monotask column create "$board_id" "Todo" --json | jq -r '.id')
+[ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$org_name' — verify monotask is installed (run: monotask --version)"; exit 1; }
+
+# Step 2 — Board (created only after space is confirmed)
+board_id=$(monotask board create "org-tasks" --json | jq -r '.id // empty')
+[ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board"; exit 1; }
+
+# Step 3 — Link board to space immediately
+monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+
+# Step 4 — Columns
+todo_col_id=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
 doing_col_id=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
-done_col_id=$(monotask column create "$board_id" "Done" --json | jq -r '.id')
-[ -n "$space_id" ] && monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+done_col_id=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
 ```
 
 Patch the saved org config with the board and column IDs:

package/.claude/skills/mastermind/finance.md

@@ -45,7 +45,19 @@ If this skill is invoked directly (not by master):
 
 1. Load brain context following _protocol.md Brain Load Procedure (namespace: `finance`)
 2. Run intake from _intake.md if prompt is vague
-3. Create or find monotask space `<project_name>`, create board `finance`
+3. Follow _protocol.md Monotask Space+Board Setup Procedure:
+   ```bash
+   project_name="${project_name:-$(basename "$PWD")}"
+   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
+   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
+   board_id=$(monotask board create "finance" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create finance board"; exit 1; }
+   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
+   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+   ```
 4. Proceed with complexity assessment below
 5. At end: follow _protocol.md Brain Write Procedure (namespace: `finance`)
 
@@ -79,8 +91,8 @@ STEP 2 — CREATE TASKS
 For each workstream, create a monotask card on the project board. First look up column IDs and assign shell variables:
 ```bash
 columns=$(monotask column list "$BOARD_ID" --json)
-COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Todo" or .name == "Backlog") | .id' | head -1)
-COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.name == "Done") | .id' | head -1)
+COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
 ```
 Then create the card:
 ```bash