@monoes/monomindcli 1.9.16 → 1.9.17

package/.claude/commands/mastermind/master.md

@@ -199,24 +199,42 @@ for domain in $domains_needed; do
   # Find existing board by canonical name — reuse across runs
   board_id=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$canonical" | head -1)
 
+  # Domain-specific column schema:
+  #   idea    → New | Evaluated | Elaborated | Tasked | Iced | Rejected   (intake = "New")
+  #   all others → Todo | In Progress | Human in Loop | Review | Done | Cancelled (intake = "Todo")
+  if [ "$domain" = "idea" ]; then
+    intake_col_name="New"
+  else
+    intake_col_name="Todo"
+  fi
+
   if [ -n "$board_id" ]; then
     echo "Reusing board: $board_id ($canonical)"
-    # Fetch existing column IDs
     cols_json=$(monotask column list "$board_id" --json 2>/dev/null || echo '[]')
-    todo_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Todo" or .title=="Backlog")] | .[0].id // empty')
-    doing_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Doing" or .title=="In Progress")] | .[0].id // empty')
+    todo_col=$(echo "$cols_json" | jq -r --arg n "$intake_col_name" '[.[] | select(.title==$n)] | .[0].id // empty')
+    doing_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="In Progress" or .title=="Doing")] | .[0].id // empty')
     done_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Done")] | .[0].id // empty')
   else
     echo "Creating board: $canonical"
     board_id=$(monotask board create --space "$space_id" "$canonical" --json 2>/dev/null | jq -r '.id // empty')
     [ -z "$board_id" ] && { echo "ERROR: Failed to create board '$canonical'"; 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 // empty')
-    [ -z "$todo_col" ] && { echo "ERROR: Failed to create Todo column for $domain"; exit 1; }
-    doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id // empty')
-    [ -z "$doing_col" ] && { echo "ERROR: Failed to create Doing column for $domain"; exit 1; }
-    done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id // empty')
-    [ -z "$done_col" ] && { echo "ERROR: Failed to create Done column for $domain"; exit 1; }
+    if [ "$domain" = "idea" ]; then
+      todo_col=$(monotask column create "$board_id" "New"        --json | jq -r '.id // empty')
+      doing_col=$(monotask column create "$board_id" "Evaluated" --json | jq -r '.id // empty')
+      monotask column create "$board_id" "Elaborated" --json >/dev/null
+      monotask column create "$board_id" "Tasked"     --json >/dev/null
+      monotask column create "$board_id" "Iced"       --json >/dev/null
+      done_col=$(monotask column create "$board_id" "Rejected" --json | jq -r '.id // empty')
+    else
+      todo_col=$(monotask column create "$board_id" "Todo"           --json | jq -r '.id // empty')
+      doing_col=$(monotask column create "$board_id" "In Progress"   --json | jq -r '.id // empty')
+      monotask column create "$board_id" "Human in Loop" --json >/dev/null
+      monotask column create "$board_id" "Review"        --json >/dev/null
+      done_col=$(monotask column create "$board_id" "Done" --json | jq -r '.id // empty')
+      monotask column create "$board_id" "Cancelled"     --json >/dev/null
+    fi
+    [ -z "$todo_col" ] && { echo "ERROR: Failed to create intake column for $domain"; exit 1; }
   fi
 
   domain_goal=$(jq -r --arg d "$domain" '.domain_goals[$d] // empty' "$SESSION_STATE")
@@ -243,6 +261,16 @@ echo "Session state saved to current.json"
 
 **BEFORE THIS STEP:** If `idea` is in `domains_needed`, invoke `Skill("mastermind:idea")` directly now (master context has Skill tool access). Pass the resolved prompt, project path, and mode. Write the result to `.monomind/sessions/<SESSION_ID>/idea.json` and mark the `idea` domain as handled. Do NOT include `idea` in the Task spawning below.
 
+**IDEA PIPELINE REQUIREMENT:** `mastermind:idea` runs a multi-step pipeline (Steps 3–6 inside idea.md). You MUST follow all of those steps — do NOT shortcut to manually creating cards. The full pipeline is:
+- Step 3: Board setup — find-or-create `<project_name>-idea` board (master's Step 6 already created it with correct columns: New → Evaluated → Elaborated → Tasked → Iced → Rejected). Load column IDs from existing board.
+- Step 4: Spawn Idea Manager agent (coordinator) with specialist sub-agents per angle — generates ideas as cards in the `New` column.
+- Step 5: Spawn PM agent for validation — moves each card to `Evaluated`, `Iced`, or `Rejected`, sets impact/effort.
+- Step 6a: Elaboration agents enrich each `Evaluated` card and move it to `Elaborated`.
+- Step 6b: User gate (skip in auto mode).
+- Step 6c: Task decomposition — creates subtask cards on `<project_name>-tasks-dev` and `<project_name>-tasks-ops` boards, linked as subtasks of their parent idea card. Moves parent idea cards to `Tasked`.
+
+Skipping any of these steps produces an incomplete pipeline run — card content is generated but no evaluation, elaboration, or task breakdown occurs.
+
 **Before spawning**, select the best domain manager agent type from the registry for each active domain. Do not hardcode `coordinator` — pick the agent whose expertise best fits the domain goal.
 
 **BASH TOOL REQUIREMENT:** Domain managers must run `monotask` CLI commands. Only use subagent_types that include Bash in their tool list. If the registry returns an agent without Bash (e.g. `Product Manager`, `Backend Architect`), override it with `general-purpose` (which has all tools). Agents without Bash cannot create cards, emit curl events, or write session files — they will silently produce degraded output.

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

@@ -249,6 +249,15 @@ curl -s -o /dev/null -X POST "http://localhost:4242/api/mastermind/event" \
 
 **Board naming convention:** Boards are named `<project_name>-<domain>` (e.g. `factory-idea`, `factory-build`). This canonical name is stable across runs — find the existing board first, create only if it does not exist.
 
+**Column schemas by domain — use these exact column names, in this order:**
+
+| Domain | Columns (left → right) | Intake column |
+|---|---|---|
+| `idea` | New → Evaluated → Elaborated → Tasked → Iced → Rejected | New |
+| `build`, `release`, `architect`, `review` | Todo → In Progress → Human in Loop → Review → Done → Cancelled | Todo |
+| `marketing`, `content`, `sales`, `ops`, `finance`, `research` | Todo → In Progress → Human in Loop → Review → Done → Cancelled | Todo |
+| Task boards (`<proj>-tasks-dev`, `<proj>-tasks-ops`) | Backlog → Todo → In Progress → Human in Loop → Review → Done → Cancelled | Todo |
+
 Every mastermind run that needs a task board MUST:
 1. Resolve the space (find existing or create new) — space name = `project_name`
 2. Find existing board by canonical name `<project_name>-<domain>` or create it with `--space`

package/.claude/skills/mastermind/idea.md

@@ -69,48 +69,46 @@ For simple prompts (single agent, single output):
 Set up the space and ideation board. The ideation board has a dedicated pipeline with six columns (not master's board).
 
 ```bash
+# Compatible with macOS bash 3.2
 project_name="${project_name:-$(basename "$PWD")}"
 date=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+idea_canonical="${project_name}-idea"
 
-# Find or create space
-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}')
+# Find or create space (by exact name)
+space_id=$(monotask space list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$project_name" | head -1)
+[ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>/dev/null | 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; }
-```
-
-**Memory-first board lookup:** Check memory for `"mastermind-idea board_id"` in namespace `monomind`. If a board ID is returned, use it as `BOARD_ID` and look up the existing column IDs. Otherwise, create the board:
-
-```bash
-BOARD_ID=$(monotask board create "Ideas & Innovation" --json | jq -r '.id // empty')
-[ -z "$BOARD_ID" ] && { echo "ERROR: Failed to create Ideas & Innovation board"; exit 1; }
-monotask space boards add "$space_id" "$BOARD_ID" >/dev/null 2>&1 || true
-npx monomind@latest memory store --key "mastermind-idea board_id" --value "$BOARD_ID" --namespace monomind
-
-# Create columns in pipeline order
-COL_NEW=$(monotask column create "$BOARD_ID" "New" --json | jq -r '.id')
-COL_EVALUATED=$(monotask column create "$BOARD_ID" "Evaluated" --json | jq -r '.id')
-COL_ELABORATED=$(monotask column create "$BOARD_ID" "Elaborated" --json | jq -r '.id')
-COL_TASKED=$(monotask column create "$BOARD_ID" "Tasked" --json | jq -r '.id')
-COL_ICED=$(monotask column create "$BOARD_ID" "Iced" --json | jq -r '.id')
-COL_REJECTED=$(monotask column create "$BOARD_ID" "Rejected" --json | jq -r '.id')
-```
 
-If the board already existed, look up column IDs:
-
-```bash
-columns=$(monotask column list "$BOARD_ID" --json)
-COL_NEW=$(echo "$columns"       | jq -r '.[] | select(.title == "New")        | .id' | head -1)
-COL_EVALUATED=$(echo "$columns" | jq -r '.[] | select(.title == "Evaluated")  | .id' | head -1)
-COL_ELABORATED=$(echo "$columns"| jq -r '.[] | select(.title == "Elaborated") | .id' | head -1)
-COL_TASKED=$(echo "$columns"    | jq -r '.[] | select(.title == "Tasked")     | .id' | head -1)
-COL_ICED=$(echo "$columns"      | jq -r '.[] | select(.title == "Iced")       | .id' | head -1)
-COL_REJECTED=$(echo "$columns"  | jq -r '.[] | select(.title == "Rejected")   | .id' | head -1)
-[ -z "$COL_NEW" ]        && { echo "ERROR: Could not find 'New' column on BOARD_ID=$BOARD_ID"; exit 1; }
-[ -z "$COL_EVALUATED" ]  && { echo "ERROR: Could not find 'Evaluated' column on BOARD_ID=$BOARD_ID"; exit 1; }
-[ -z "$COL_ELABORATED" ] && { echo "ERROR: Could not find 'Elaborated' column on BOARD_ID=$BOARD_ID"; exit 1; }
-[ -z "$COL_TASKED" ]     && { echo "ERROR: Could not find 'Tasked' column on BOARD_ID=$BOARD_ID"; exit 1; }
-[ -z "$COL_ICED" ]       && { echo "ERROR: Could not find 'Iced' column on BOARD_ID=$BOARD_ID"; exit 1; }
-[ -z "$COL_REJECTED" ]   && { echo "ERROR: Could not find 'Rejected' column on BOARD_ID=$BOARD_ID"; exit 1; }
+# Find existing idea board by canonical name — reuse across runs (same pattern as master Step 6)
+BOARD_ID=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$idea_canonical" | head -1)
+
+if [ -n "$BOARD_ID" ]; then
+  echo "Reusing idea board: $BOARD_ID ($idea_canonical)"
+  columns=$(monotask column list "$BOARD_ID" --json)
+  COL_NEW=$(echo "$columns"       | jq -r '.[] | select(.title == "New")        | .id' | head -1)
+  COL_EVALUATED=$(echo "$columns" | jq -r '.[] | select(.title == "Evaluated")  | .id' | head -1)
+  COL_ELABORATED=$(echo "$columns"| jq -r '.[] | select(.title == "Elaborated") | .id' | head -1)
+  COL_TASKED=$(echo "$columns"    | jq -r '.[] | select(.title == "Tasked")     | .id' | head -1)
+  COL_ICED=$(echo "$columns"      | jq -r '.[] | select(.title == "Iced")       | .id' | head -1)
+  COL_REJECTED=$(echo "$columns"  | jq -r '.[] | select(.title == "Rejected")   | .id' | head -1)
+  [ -z "$COL_NEW" ]        && { echo "ERROR: 'New' column missing on board $BOARD_ID — was board created with wrong schema?"; exit 1; }
+  [ -z "$COL_EVALUATED" ]  && { echo "ERROR: 'Evaluated' column missing on board $BOARD_ID"; exit 1; }
+  [ -z "$COL_ELABORATED" ] && { echo "ERROR: 'Elaborated' column missing on board $BOARD_ID"; exit 1; }
+  [ -z "$COL_TASKED" ]     && { echo "ERROR: 'Tasked' column missing on board $BOARD_ID"; exit 1; }
+  [ -z "$COL_ICED" ]       && { echo "ERROR: 'Iced' column missing on board $BOARD_ID"; exit 1; }
+  [ -z "$COL_REJECTED" ]   && { echo "ERROR: 'Rejected' column missing on board $BOARD_ID"; exit 1; }
+else
+  echo "Creating idea board: $idea_canonical"
+  BOARD_ID=$(monotask board create --space "$space_id" "$idea_canonical" --json 2>/dev/null | jq -r '.id // empty')
+  [ -z "$BOARD_ID" ] && { echo "ERROR: Failed to create idea board '$idea_canonical'"; exit 1; }
+  monotask space boards add "$space_id" "$BOARD_ID" >/dev/null 2>&1 || true
+  COL_NEW=$(monotask column create "$BOARD_ID"       "New"        --json | jq -r '.id')
+  COL_EVALUATED=$(monotask column create "$BOARD_ID" "Evaluated"  --json | jq -r '.id')
+  COL_ELABORATED=$(monotask column create "$BOARD_ID" "Elaborated" --json | jq -r '.id')
+  COL_TASKED=$(monotask column create "$BOARD_ID"    "Tasked"     --json | jq -r '.id')
+  COL_ICED=$(monotask column create "$BOARD_ID"      "Iced"       --json | jq -r '.id')
+  COL_REJECTED=$(monotask column create "$BOARD_ID"  "Rejected"   --json | jq -r '.id')
+fi
 ```
 
 **After either branch above, validate and echo all values.** This is the canonical source for Step 4 Task construction.
@@ -802,56 +800,62 @@ END_TASKS_OUTPUT`
 
 **Dev task board** (`feature` / `technical-baseline` → `Implementation Tasks`):
 
-Check memory for `"implementation-tasks board_id"` in namespace `monomind`. If found, use it as `TASK_BOARD_ID`. Otherwise create it:
+Canonical board name: `${project_name}-tasks-dev`. Find-or-create:
 
 ```bash
-TASK_BOARD_ID=$(monotask board create "Implementation Tasks" --json | jq -r '.id // empty')
-monotask space boards add "$space_id" "$TASK_BOARD_ID" >/dev/null 2>&1 || true
-npx monomind@latest memory store --key "implementation-tasks board_id" --value "$TASK_BOARD_ID" --namespace monomind
-monotask column create "$TASK_BOARD_ID" "Backlog"       --json >/dev/null
-monotask column create "$TASK_BOARD_ID" "Todo"          --json >/dev/null
-monotask column create "$TASK_BOARD_ID" "In Progress"   --json >/dev/null
-monotask column create "$TASK_BOARD_ID" "Review"        --json >/dev/null
-monotask column create "$TASK_BOARD_ID" "Human in Loop" --json >/dev/null
-monotask column create "$TASK_BOARD_ID" "Done"          --json >/dev/null
-```
-
-Look up and validate column IDs:
-```bash
-[ -z "$TASK_BOARD_ID" ] && { echo "ERROR: TASK_BOARD_ID is empty — aborting to prevent card creation on null board"; exit 1; }
-task_columns=$(monotask column list "$TASK_BOARD_ID" --json)
-TASK_COL_TODO=$(echo "$task_columns"    | jq -r '.[] | select(.title == "Todo")    | .id' | head -1)
-TASK_COL_BACKLOG=$(echo "$task_columns" | jq -r '.[] | select(.title == "Backlog") | .id' | head -1)
-[ -z "$TASK_COL_TODO" ]    && { echo "ERROR: Could not find 'Todo' column on TASK_BOARD_ID=$TASK_BOARD_ID"; exit 1; }
-[ -z "$TASK_COL_BACKLOG" ] && { echo "ERROR: Could not find 'Backlog' column on TASK_BOARD_ID=$TASK_BOARD_ID"; exit 1; }
+dev_task_canonical="${project_name}-tasks-dev"
+TASK_BOARD_ID=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$dev_task_canonical" | head -1)
+if [ -n "$TASK_BOARD_ID" ]; then
+  echo "Reusing dev task board: $TASK_BOARD_ID ($dev_task_canonical)"
+  task_columns=$(monotask column list "$TASK_BOARD_ID" --json)
+  TASK_COL_TODO=$(echo "$task_columns"    | jq -r '.[] | select(.title=="Todo")           | .id' | head -1)
+  TASK_COL_BACKLOG=$(echo "$task_columns" | jq -r '.[] | select(.title=="Backlog")        | .id' | head -1)
+else
+  echo "Creating dev task board: $dev_task_canonical"
+  TASK_BOARD_ID=$(monotask board create --space "$space_id" "$dev_task_canonical" --json 2>/dev/null | jq -r '.id // empty')
+  [ -z "$TASK_BOARD_ID" ] && { echo "ERROR: Failed to create dev task board"; exit 1; }
+  monotask space boards add "$space_id" "$TASK_BOARD_ID" >/dev/null 2>&1 || true
+  TASK_COL_BACKLOG=$(monotask column create "$TASK_BOARD_ID" "Backlog"       --json | jq -r '.id')
+  TASK_COL_TODO=$(monotask column create "$TASK_BOARD_ID"    "Todo"          --json | jq -r '.id')
+  monotask column create "$TASK_BOARD_ID" "In Progress"   --json >/dev/null
+  monotask column create "$TASK_BOARD_ID" "Human in Loop" --json >/dev/null
+  monotask column create "$TASK_BOARD_ID" "Review"        --json >/dev/null
+  monotask column create "$TASK_BOARD_ID" "Done"          --json >/dev/null
+  monotask column create "$TASK_BOARD_ID" "Cancelled"     --json >/dev/null
+fi
+[ -z "$TASK_BOARD_ID" ]    && { echo "ERROR: TASK_BOARD_ID empty — aborting"; exit 1; }
+[ -z "$TASK_COL_TODO" ]    && { echo "ERROR: Could not find Todo column on dev task board"; exit 1; }
 ```
 
 ---
 
 **Ops task board** (`business-operation` → `Operations Tasks`):
 
-Check memory for `"operations-tasks board_id"` in namespace `monomind`. If found, use it as `OPS_BOARD_ID`. Otherwise create it:
+Canonical board name: `${project_name}-tasks-ops`. Find-or-create:
 
 ```bash
-OPS_BOARD_ID=$(monotask board create "Operations Tasks" --json | jq -r '.id // empty')
-monotask space boards add "$space_id" "$OPS_BOARD_ID" >/dev/null 2>&1 || true
-npx monomind@latest memory store --key "operations-tasks board_id" --value "$OPS_BOARD_ID" --namespace monomind
-monotask column create "$OPS_BOARD_ID" "Backlog"       --json >/dev/null
-monotask column create "$OPS_BOARD_ID" "Todo"          --json >/dev/null
-monotask column create "$OPS_BOARD_ID" "In Progress"   --json >/dev/null
-monotask column create "$OPS_BOARD_ID" "Review"        --json >/dev/null
-monotask column create "$OPS_BOARD_ID" "Human in Loop" --json >/dev/null
-monotask column create "$OPS_BOARD_ID" "Done"          --json >/dev/null
-```
-
-Look up and validate column IDs:
-```bash
-[ -z "$OPS_BOARD_ID" ] && { echo "ERROR: OPS_BOARD_ID is empty — aborting to prevent card creation on null board"; exit 1; }
-ops_columns=$(monotask column list "$OPS_BOARD_ID" --json)
-OPS_COL_TODO=$(echo "$ops_columns"    | jq -r '.[] | select(.title == "Todo")    | .id' | head -1)
-OPS_COL_BACKLOG=$(echo "$ops_columns" | jq -r '.[] | select(.title == "Backlog") | .id' | head -1)
-[ -z "$OPS_COL_TODO" ]    && { echo "ERROR: Could not find 'Todo' column on OPS_BOARD_ID=$OPS_BOARD_ID"; exit 1; }
-[ -z "$OPS_COL_BACKLOG" ] && { echo "ERROR: Could not find 'Backlog' column on OPS_BOARD_ID=$OPS_BOARD_ID"; exit 1; }
+ops_task_canonical="${project_name}-tasks-ops"
+OPS_BOARD_ID=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$ops_task_canonical" | head -1)
+if [ -n "$OPS_BOARD_ID" ]; then
+  echo "Reusing ops task board: $OPS_BOARD_ID ($ops_task_canonical)"
+  ops_columns=$(monotask column list "$OPS_BOARD_ID" --json)
+  OPS_COL_TODO=$(echo "$ops_columns"    | jq -r '.[] | select(.title=="Todo")    | .id' | head -1)
+  OPS_COL_BACKLOG=$(echo "$ops_columns" | jq -r '.[] | select(.title=="Backlog") | .id' | head -1)
+else
+  echo "Creating ops task board: $ops_task_canonical"
+  OPS_BOARD_ID=$(monotask board create --space "$space_id" "$ops_task_canonical" --json 2>/dev/null | jq -r '.id // empty')
+  [ -z "$OPS_BOARD_ID" ] && { echo "ERROR: Failed to create ops task board"; exit 1; }
+  monotask space boards add "$space_id" "$OPS_BOARD_ID" >/dev/null 2>&1 || true
+  OPS_COL_BACKLOG=$(monotask column create "$OPS_BOARD_ID" "Backlog"       --json | jq -r '.id')
+  OPS_COL_TODO=$(monotask column create "$OPS_BOARD_ID"    "Todo"          --json | jq -r '.id')
+  monotask column create "$OPS_BOARD_ID" "In Progress"   --json >/dev/null
+  monotask column create "$OPS_BOARD_ID" "Human in Loop" --json >/dev/null
+  monotask column create "$OPS_BOARD_ID" "Review"        --json >/dev/null
+  monotask column create "$OPS_BOARD_ID" "Done"          --json >/dev/null
+  monotask column create "$OPS_BOARD_ID" "Cancelled"     --json >/dev/null
+fi
+[ -z "$OPS_BOARD_ID" ]    && { echo "ERROR: OPS_BOARD_ID empty — aborting"; exit 1; }
+[ -z "$OPS_COL_TODO" ]    && { echo "ERROR: Could not find Todo column on ops task board"; exit 1; }
 ```
 
 ---

package/package.json

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