@monoes/monomindcli 1.9.15 → 1.9.17

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

@@ -166,95 +166,111 @@ If mode = auto: proceed immediately.
 
 Follow the Monotask Space+Board Setup Procedure from `_protocol.md`. Resolve the space **once**, then create one board per active domain. Use `project_name` as the space name so all boards across repos and domains share the same space.
 
-```bash
-# Require bash 4.3+ for associative arrays and namerefs (local -n introduced in 4.3)
-# macOS ships bash 3.2; install via: brew install bash
-(( BASH_VERSINFO[0] * 100 + BASH_VERSINFO[1] < 403 )) && \
-  { echo "ERROR: bash 4.3+ required for namerefs (current: $BASH_VERSION). Install: brew install bash"; exit 1; }
+**Board naming convention:** Every board is named `<project_name>-<domain>` (e.g. `factory-idea`, `factory-build`). This canonical name is stable across runs — mastermind finds the existing board instead of creating a new one every time.
 
+```bash
+# Compatible with macOS bash 3.2 — no associative arrays, uses jq accumulation instead
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
 SESSION_STATE="$REPO_ROOT/.monomind/sessions/current.json"
 
-# Reload persisted context (this is a fresh shell; Step 3 wrote these)
 SESSION_ID=$(jq -r '.sessionId // empty' "$SESSION_STATE" 2>/dev/null)
 [ -z "$SESSION_ID" ] && { echo "ERROR: SESSION_ID missing in current.json — run Step 3 first"; exit 1; }
 project_name=$(jq -r '.project_name // ""' "$SESSION_STATE")
 [ -z "$project_name" ] && { echo "ERROR: project_name is empty in current.json — run Step 3 first"; exit 1; }
 resolved_prompt=$(jq -r '.prompt // ""' "$SESSION_STATE")
 
-# domains_needed: NOT yet in current.json at this point — must be LLM-substituted inline.
 # LLM: replace DOMAINS_LIST_HERE with space-separated domain names, e.g.: build marketing sales
-# Domain names must be single words (no spaces). Example: "build marketing sales"
+domains_needed="DOMAINS_LIST_HERE"
+[ "$domains_needed" = "DOMAINS_LIST_HERE" ] && { echo "ERROR: LLM did not substitute DOMAINS_LIST_HERE"; exit 1; }
+[ -z "$domains_needed" ] && { echo "ERROR: domains_needed is empty — nothing to do"; exit 1; }
 
-# Resolve space once for all domains
-# Use awk with literal pipe to avoid BSD awk \| regex fragility
-space_id=$(monotask space list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$2); if($2==n) gsub(/^ +| +$/,"",$1); if($2==n) print $1}' n="$project_name" | head -1)
+# Resolve space once — find existing by exact name or create
+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; }
+echo "Space: $space_id ($project_name)"
 
-# Associative arrays — no eval, no injection risk
-declare -A board_ids todo_cols doing_cols done_cols domain_goals
-
-# Hydrate domain_goals from Step 4's current.json write — prevents Step 4 extraction being clobbered
-# Use NUL-delimited pairs (not @tsv) to safely handle backslashes, tabs, and other special chars in goals
-while IFS= read -r -d '' k && IFS= read -r -d '' v; do
-  [[ -n "$k" ]] && domain_goals[$k]="$v"
-done < <(jq -j '.domain_goals // {} | to_entries[] | (.key + "\u0000" + (.value // "") + "\u0000")' "$SESSION_STATE" 2>/dev/null)
+# jq accumulation state (replaces bash 4.3+ associative arrays)
+state_patch='{}'
 
-# Loop over every active domain — LLM: replace DOMAINS_LIST_HERE with the resolved domain list
-domains_needed="DOMAINS_LIST_HERE"
-[ "$domains_needed" = "DOMAINS_LIST_HERE" ] && { echo "ERROR: LLM did not substitute DOMAINS_LIST_HERE with domain names"; exit 1; }
-[ -z "$domains_needed" ] && { echo "ERROR: domains_needed is empty — nothing to do"; exit 1; }
 for domain in $domains_needed; do
-  board_id=$(monotask board create "$domain" --json | jq -r '.id // empty')
-  [ -z "$board_id" ] && { echo "ERROR: Failed to create $domain board"; exit 1; }
-  monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 \
-    || echo "WARN: could not attach $domain board to space $space_id (non-fatal)"
-  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; }
-  board_ids[$domain]=$board_id
-  todo_cols[$domain]=$todo_col
-  doing_cols[$domain]=$doing_col
-  done_cols[$domain]=$done_col
-  # Fall back to full prompt only for domains not extracted by Step 4
-  [ -z "${domain_goals[$domain]}" ] && domain_goals[$domain]="$resolved_prompt"
-done
+  canonical="${project_name}-${domain}"
 
-# Persist all session state needed by later shells — board/col IDs, goals, domain list
-# (each Bash tool call is a fresh shell — associative arrays don't survive)
-_to_json_map() {
-  local -n _arr=$1
-  for k in "${!_arr[@]}"; do
-    jq -n --arg k "$k" --arg v "${_arr[$k]}" '{key:$k,value:$v}'
-  done | jq -s 'from_entries // {}'
-}
-domains_goals_json=$(_to_json_map domain_goals)
-board_ids_json=$(_to_json_map board_ids)
-todo_cols_json=$(_to_json_map todo_cols)
-doing_cols_json=$(_to_json_map doing_cols)
-done_cols_json=$(_to_json_map done_cols)
+  # 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)"
+    cols_json=$(monotask column list "$board_id" --json 2>/dev/null || echo '[]')
+    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
+    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")
+  [ -z "$domain_goal" ] && domain_goal="$resolved_prompt"
+
+  state_patch=$(echo "$state_patch" | jq \
+    --arg d "$domain" --arg b "$board_id" \
+    --arg t "$todo_col" --arg g "$doing_col" --arg e "$done_col" \
+    --arg goal "$domain_goal" \
+    '.board_ids[$d]=$b | .todo_cols[$d]=$t | .doing_cols[$d]=$g | .done_cols[$d]=$e | .domain_goals[$d]=$goal')
+
+  echo "DOMAIN=$domain BOARD=$board_id TODO=$todo_col DOING=$doing_col DONE=$done_col"
+done
+
+# Persist to current.json — one atomic merge
 jq --arg domains "$domains_needed" \
-   --argjson goals "$domains_goals_json" \
-   --argjson boards "$board_ids_json" \
-   --argjson todos "$todo_cols_json" \
-   --argjson doings "$doing_cols_json" \
-   --argjson dones "$done_cols_json" \
-  '. + {domains_needed:($domains | split(" ") | map(select(length>0))),
-         domain_goals:$goals, board_ids:$boards,
-         todo_cols:$todos, doing_cols:$doings, done_cols:$dones}' \
-  "$REPO_ROOT/.monomind/sessions/current.json" > "$REPO_ROOT/.monomind/sessions/current.json.tmp" \
-  && mv "$REPO_ROOT/.monomind/sessions/current.json.tmp" "$REPO_ROOT/.monomind/sessions/current.json"
+   --argjson patch "$state_patch" \
+  '. + $patch + {domains_needed:($domains | split(" ") | map(select(length>0)))}' \
+  "$SESSION_STATE" > "$SESSION_STATE.tmp" && mv "$SESSION_STATE.tmp" "$SESSION_STATE"
+echo "Session state saved to current.json"
 ```
 
 ### Step 7 — Spawn Domain Managers
 
 **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

@@ -247,53 +247,87 @@ curl -s -o /dev/null -X POST "http://localhost:4242/api/mastermind/event" \
 
 **Always follow this exact order — never create a board without first ensuring a space exists.**
 
+**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. 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
+2. Find existing board by canonical name `<project_name>-<domain>` or create it with `--space`
+3. Fetch column IDs from existing board OR create columns for new board
+4. 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)
+# Compatible with macOS bash 3.2
 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; }
+canonical="${project_name}-<domain>"
 
-# Step 3 — Link board to space immediately
-monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
+# Step 1 — Resolve space
+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' — verify monotask is installed (monotask --version)"; exit 1; }
 
-# 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')
+# Step 2 — Find existing board by canonical name or create
+board_id=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$canonical" | head -1)
+if [ -n "$board_id" ]; then
+  # Step 3a — Fetch column IDs from existing board
+  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')
+  done_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Done")] | .[0].id // empty')
+else
+  # Step 3b — Create board and columns
+  board_id=$(monotask board create --space "$space_id" "$canonical" --json | 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')
+  doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
+  done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
+fi
 ```
 
-When master.md runs multiple domains, resolve the space **once** before the loop, then repeat steps 2–4 per domain:
+When master.md runs multiple domains, resolve the space **once** before the loop, then repeat steps 2–3 per domain using jq accumulation (no bash 4.3+ needed):
 
 ```bash
-# Resolve space once
+# Compatible with macOS bash 3.2 — jq accumulation instead of declare -A
 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}')
+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; }
 
-# 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')
+state_patch='{}'
+for domain in build marketing ops; do   # substitute actual domain list
+  canonical="${project_name}-${domain}"
+  board_id=$(monotask board list 2>/dev/null | awk -F'|' '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);if($2==n)print $1}' n="$canonical" | head -1)
+  if [ -n "$board_id" ]; then
+    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')
+    done_col=$(echo "$cols_json" | jq -r '[.[] | select(.title=="Done")] | .[0].id // empty')
+  else
+    board_id=$(monotask board create --space "$space_id" "$canonical" --json | jq -r '.id // empty')
+    [ -z "$board_id" ] && { echo "ERROR: Failed to create $canonical 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')
+  fi
+  state_patch=$(echo "$state_patch" | jq \
+    --arg d "$domain" --arg b "$board_id" \
+    --arg t "$todo_col" --arg g "$doing_col" --arg e "$done_col" \
+    '.board_ids[$d]=$b | .todo_cols[$d]=$t | .doing_cols[$d]=$g | .done_cols[$d]=$e')
+done
 ```
 
 ---

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

@@ -69,42 +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)
+# 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.
@@ -510,44 +514,81 @@ END_ELABORATION_OUTPUT`
 })
 ```
 
-After all agents complete, merge their outputs per idea (same card_id → concatenate findings). For each idea, write findings to the card description and as comments, then move the card:
+Wait for all background agents to complete (do not proceed until all — or two, if only one category — return ELABORATION_OUTPUT blocks). Then build `merged_elaboration_json` by merging agent outputs per `card_id` and injecting `category` from `verdicts_output_json`:
 
 ```bash
-# Set the card description to the merged elaboration findings (this is the primary content field)
-if [ "$category" = "business-operation" ]; then
-  monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
+# Assign each agent's ELABORATION_OUTPUT JSON array from its output block:
+dev_researcher_json='<ELABORATION_OUTPUT array from the dev researcher agent>'
+dev_codebase_json='<ELABORATION_OUTPUT array from the dev code-explorer agent>'
+ops_researcher_json='<ELABORATION_OUTPUT array from the ops researcher agent>'
+ops_pm_json='<ELABORATION_OUTPUT array from the ops PM agent>'
+# Use '[]' for any track that had no ideas (e.g. if all ideas were dev, set ops_* to '[]')
+
+# Merge dev track: join researcher + codebase findings by card_id, inject category from verdicts
+dev_merged=$(jq -n \
+  --argjson r "$dev_researcher_json" \
+  --argjson c "$dev_codebase_json" \
+  --argjson v "$verdicts_output_json" \
+  '[$r[] | {card_id: .card_id, blocking_issue: .blocking_issue,
+     researcher_findings: .findings,
+     codebase_findings: ([$c[] | select(.card_id == .card_id)] | first | .findings // ""),
+     category: ([$v[] | select(.card_id == .card_id)] | first | .category // "feature")}]')
+
+# Merge ops track: join researcher + PM findings by card_id, inject category
+ops_merged=$(jq -n \
+  --argjson r "$ops_researcher_json" \
+  --argjson p "$ops_pm_json" \
+  --argjson v "$verdicts_output_json" \
+  '[$r[] | {card_id: .card_id, blocking_issue: .blocking_issue,
+     researcher_findings: .findings,
+     pm_findings: ([$p[] | select(.card_id == .card_id)] | first | .findings // ""),
+     category: ([$v[] | select(.card_id == .card_id)] | first | .category // "business-operation")}]')
+
+# Combine both tracks
+merged_elaboration_json=$(jq -s 'add' <(echo "$dev_merged") <(echo "$ops_merged"))
+```
+
+Use process substitution (not a pipeline) so the while loop runs in the main shell and variables remain in scope after `done`:
+
+```bash
+while IFS= read -r idea; do
+  CARD_ID=$(echo "$idea"        | jq -r '.card_id')
+  category=$(echo "$idea"       | jq -r '.category')
+  blocking_issue=$(echo "$idea" | jq -r '.blocking_issue // empty')
+
+  if [ "$category" = "business-operation" ]; then
+    researcher_findings=$(echo "$idea" | jq -r '.researcher_findings')
+    pm_findings=$(echo "$idea"         | jq -r '.pm_findings')
+    monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
 
 ### Industry context & benchmarks:
-<researcher findings>
+$researcher_findings
 
 ### Feasibility & stakeholder impact:
-<PM findings>"
-else
-  # feature or technical-baseline
-  monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
+$pm_findings"
+    monotask card comment add "$BOARD_ID" "$CARD_ID" "Industry context & benchmarks: $researcher_findings"
+    monotask card comment add "$BOARD_ID" "$CARD_ID" "Feasibility & stakeholder impact: $pm_findings"
+  else
+    researcher_findings=$(echo "$idea" | jq -r '.researcher_findings')
+    codebase_findings=$(echo "$idea"   | jq -r '.codebase_findings')
+    monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
 
 ### Edge cases & prior art:
-<researcher findings>
+$researcher_findings
 
 ### Codebase constraints:
-<code-explorer findings>"
-fi
-
-# Also add each finding as a comment for traceability
-# Dev ideas:
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Edge cases & prior art: <researcher findings>"
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Codebase constraints: <code-explorer findings>"
-
-# Business-operation ideas:
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Industry context & benchmarks: <researcher findings>"
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Feasibility & stakeholder impact: <PM findings>"
-
-# If neither agent found a blocking issue:
-monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ELABORATED" --json
-
-# If either agent found a blocking issue (mutually exclusive with the above):
-monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ICED" --json
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Blocked during elaboration: <issue>"
+$codebase_findings"
+    monotask card comment add "$BOARD_ID" "$CARD_ID" "Edge cases & prior art: $researcher_findings"
+    monotask card comment add "$BOARD_ID" "$CARD_ID" "Codebase constraints: $codebase_findings"
+  fi
+
+  if [ -n "$blocking_issue" ]; then
+    monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ICED" --json
+    monotask card comment add "$BOARD_ID" "$CARD_ID" "Blocked during elaboration: $blocking_issue"
+  else
+    monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ELABORATED" --json
+  fi
+done < <(echo "$merged_elaboration_json" | jq -c '.[]')
 ```
 
 #### 6b. User Confirmation Gate
@@ -556,6 +597,10 @@ monotask card comment add "$BOARD_ID" "$CARD_ID" "Blocked during elaboration: <i
 
 **Confirm mode only:** If `mode` is `confirm` (default), present a review table of all elaborated ideas to the user.
 
+Build the table from `verdicts_output_json` (filtered to `verdict == "evaluated"`). For each row:
+- **Impact** and **Effort** come from `.impact` and `.effort` fields in `verdicts_output_json`
+- **Track**: `feature` or `technical-baseline` → `dev`; `business-operation` → `ops`
+
 Print this exact format:
 
 ```
@@ -654,7 +699,7 @@ echo "Dev decomp: $dev_decomp_agent | Ops decomp: $ops_decomp_agent"
 ```
 
 **CRITICAL — Variable substitution required for Step 6c Task calls:**
-Before constructing each Task prompt, replace `${brain_context}`, `${prompt}`, `${project_name}`, and `${dev_ideas_elaborated}` / `${ops_ideas_elaborated}` with actual literal text. Build those lists from the VERDICTS_OUTPUT and ELABORATION_OUTPUT results:
+Before constructing each Task prompt, replace `${brain_context}`, `${prompt}`, `${project_name}`, `${dev_ideas_elaborated}`, and `${ops_ideas_elaborated}` with actual literal text. Also substitute the `subagent_type` values: replace `dev_decomp_agent` and `ops_decomp_agent` with the string values echoed by the registry selection above (e.g. `"Software Architect"`). Build those lists from the VERDICTS_OUTPUT and ELABORATION_OUTPUT results:
 
 ```bash
 # Build elaborated idea lists including card comments (full context for decomposition agents)
@@ -755,64 +800,91 @@ 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:
-
-```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
-```
+Canonical board name: `${project_name}-tasks-ops`. Find-or-create:
 
-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; }
 ```
 
 ---
 
-**Create task cards** — for each task in the merged TASKS_OUTPUT:
+**Assign TASKS_OUTPUT from each decomposition agent, then merge and iterate:**
 
 ```bash
-if [ "$category" = "business-operation" ]; then
+# Parse the TASKS_OUTPUT block from the dev decomp agent's response and assign:
+dev_tasks_json='<TASKS_OUTPUT JSON array from dev decomp agent, or [] if no dev ideas>'
+# Parse the TASKS_OUTPUT block from the ops decomp agent's response and assign:
+ops_tasks_json='<TASKS_OUTPUT JSON array from ops decomp agent, or [] if no ops ideas>'
+
+merged_tasks_json=$(jq -s 'add' <(echo "$dev_tasks_json") <(echo "$ops_tasks_json"))
+
+# Use process substitution (not a pipeline) so variables set inside the loop
+# remain in scope after done — needed for the parent-annotation step below.
+# Also initialise the subtask-accumulator map before the loop.
+declare -A parent_subtask_summaries  # parent_card_id -> newline-separated task summary lines
+
+while IFS= read -r task; do
+  parent_card_id=$(echo "$task"    | jq -r '.parent_card_id')
+  title=$(echo "$task"             | jq -r '.title')
+  description=$(echo "$task"       | jq -r '.description')
+  category=$(echo "$task"          | jq -r '.category')
+  agent=$(echo "$task"             | jq -r '.agent')
+  task_effort=$(echo "$task"       | jq -r '.effort')
+  has_prerequisites=$(echo "$task" | jq -r '.has_prerequisites')
+
+  if [ "$category" = "business-operation" ]; then
   TARGET_BOARD="$OPS_BOARD_ID"
   COL_TARGET=$([ "$has_prerequisites" = "true" ] && echo "$OPS_COL_BACKLOG" || echo "$OPS_COL_TODO")
   BOARD_LABEL="Operations Tasks"
@@ -823,8 +895,11 @@ else
 fi
 
 # Inherit impact and effort from parent idea — look up from verdicts_output_json by parent_card_id
-parent_impact=$(echo "$verdicts_output_json" | jq -r --arg id "$parent_card_id" '.[] | select(.card_id == $id) | .impact')
-parent_effort=$(echo "$verdicts_output_json" | jq -r --arg id "$parent_card_id" '.[] | select(.card_id == $id) | .effort')
+parent_impact=$(echo "$verdicts_output_json" | jq -r --arg id "$parent_card_id" '.[] | select(.card_id == $id) | .impact // 5')
+parent_effort=$(echo "$verdicts_output_json" | jq -r --arg id "$parent_card_id" '.[] | select(.card_id == $id) | .effort // 5')
+# Default to 5 if lookup returned empty (e.g. parent_card_id was "UNKNOWN")
+[ -z "$parent_impact" ] && parent_impact=5
+[ -z "$parent_effort" ] && parent_effort=5
 
 # Create task card as a proper subtask of the parent idea card (cross-board link)
 # Signature: subtask add <PARENT_BOARD_ID> <PARENT_CARD_ID> <CHILD_BOARD_ID> <COL_ID> <TITLE>
@@ -841,14 +916,22 @@ PARENT IDEA IMPACT: <parent_impact>/10  PARENT IDEA EFFORT: <parent_effort>/10
 CATEGORY: <category>
 PARENT IDEA: <idea title> (card: <parent_card_id> on ideation board)"
 monotask card label add "$TARGET_BOARD" "$TASK_CARD_ID" "mastermind:idea"
-monotask card label add "$TARGET_BOARD" "$TASK_CARD_ID" "category:<category>"
+monotask card label add "$TARGET_BOARD" "$TASK_CARD_ID" "category:$category"
+
+# Accumulate subtask summary for this parent (used in the post-loop annotation step)
+parent_subtask_summaries[$parent_card_id]+="  - $title (agent: $agent, effort: $task_effort/10, board: $BOARD_LABEL)\n"
+
+done < <(echo "$merged_tasks_json" | jq -c '.[]')
 ```
 
-Group tasks by `parent_card_id`. For each parent idea, annotate and move to `Tasked`:
+After the loop, annotate each parent idea card and move it to `Tasked`:
 ```bash
-monotask card comment add "$BOARD_ID" "$parent_card_id" \
-  "Subtasks created on <board_label>: <list of titles with agent and effort>"
-monotask card move "$BOARD_ID" "$parent_card_id" "$COL_TASKED" --json
+for parent_card_id in "${!parent_subtask_summaries[@]}"; do
+  subtask_list="${parent_subtask_summaries[$parent_card_id]}"
+  monotask card comment add "$BOARD_ID" "$parent_card_id" \
+    "Subtasks created:\n${subtask_list}"
+  monotask card move "$BOARD_ID" "$parent_card_id" "$COL_TASKED" --json
+done
 ```
 
 For each entry in FLAGGED, move the idea to `Iced`:

package/package.json

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