@monoes/monomindcli 1.9.14 → 1.9.16

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

@@ -108,6 +108,8 @@ Complexity threshold for manager agent: any of these is true:
 - Has external dependencies (APIs, services)
 - Is estimated to take more than one conversation turn
 
+**DOMAIN EXCEPTION — `idea`:** The `idea` domain MUST always be handled by the master invoking `Skill("mastermind:idea")` directly — NEVER by spawning a Task agent. Spawned agents do not have Skill tool access, so delegating `idea` to a Task agent silently degrades to raw analysis with no pipeline execution. After `mastermind:idea` returns, treat its output as the `idea` domain's unified output schema and proceed to the next domain.
+
 **Per-domain goal extraction:** For each activated domain, extract a one-sentence goal from the prompt describing what that domain must accomplish. Then **run the following Bash block**, substituting `<domain_goals_json>` with a JSON object mapping each domain name to its one-sentence goal (use the full `resolved_prompt` as the value for any domain where no specific goal is extractable):
 
 ```bash
@@ -164,95 +166,87 @@ 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}"
+
+  # 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)
+
+  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')
+    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; }
+  fi
 
-# 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)
+  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.
+
 **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.
+
 **Phase A — Registry selection** (run as one Bash call; must complete before Phase C):
 
 ```bash

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

@@ -15,18 +15,18 @@ This file is a reference loaded by mastermind domain skills and master. It is NE
 Execute at the START of every mastermind run (master or standalone domain command). Load in this order:
 
 **Step A — Tier 3 core principles (all domains):**
-Call `mcp__monomind__agentdb_hierarchical-recall` with:
-- namespace: `mastermind:principles`
-- limit: 20
+Try `mcp__monobrain__agentdb_hierarchical-recall` with query `"mastermind principles"`, topK 20.
+If it returns `"AgentDB bridge not available"` or any error, fall back to:
+`mcp__monobrain__memory_search` with query `"mastermind principles"`, namespace `"mastermind:principles"`, limit 20.
 
 **Step B — Tier 2 weekly summary for this domain:**
-Call `mcp__monomind__agentdb_context-synthesize` with:
-- namespace: `mastermind:<domain>:weekly`
-- query: [current prompt keywords]
+Try `mcp__monobrain__agentdb_context-synthesize` with query `[current prompt keywords]`, maxEntries 10.
+If it fails, fall back to:
+`mcp__monobrain__memory_search` with query `[current prompt keywords]`, namespace `"mastermind:<domain>:weekly"`, limit 10.
 
 **Step C — Relevant graph nodes:**
-Call `mcp__monomind__monograph_query` with:
-- query: [3-5 keywords extracted from current prompt]
+Call `mcp__monobrain__graphify_query` with question `[3-5 keywords extracted from current prompt]`, depth 2.
+If the graph is not built yet (error: "No graph found"), skip this tier — continue without graph context.
 
 Combine all results into a **BRAIN CONTEXT** block. Insert this block before any planning, decomposition, or agent spawning step. Format:
 
@@ -55,13 +55,20 @@ score = confidence × (1 / (days_since_run + 1)) × log(uses + 1)
 - `uses`: 1 (first write)
 
 **Step 2 — Append to Tier 1 raw log:**
-Call `mcp__monomind__agentdb_hierarchical-store` with:
+Try `mcp__monobrain__agentdb_hierarchical-store` with:
 - namespace: `mastermind:<domain>:raw`
 - content: [full unified output schema YAML from this run, as a string]
 - metadata: `{ score, project, run_id, date: ISO8601, domain }`
 
+If AgentDB is unavailable, fall back to `mcp__monobrain__memory_store`:
+- key: `mastermind:<domain>:run:<run_id>`
+- value: [JSON-encoded unified output schema]
+- namespace: `mastermind:<domain>:raw`
+- tags: `["mastermind", "<domain>", "run"]`
+
 **Step 3 — Check weekly compaction trigger:**
-Call `mcp__monomind__agentdb_health` on namespace `mastermind:<domain>:raw`.
+Try `mcp__monobrain__agentdb_health` on namespace `mastermind:<domain>:raw`.
+If unavailable, call `mcp__monobrain__memory_stats` and check entry count manually.
 If `entry_count >= 20` OR `days_since_last_compaction >= 7`:
 1. Retrieve all Tier 1 entries since last compaction
 2. Produce a per-domain weekly summary (use LLM synthesis: "Summarize the key decisions, patterns, and lessons from these run logs in under 300 words")
@@ -201,25 +208,25 @@ Every mastermind run MUST emit structured events to the live dashboard via WebFe
 }
 ```
 
-### How to Emit (WebFetch pattern)
-
-```javascript
-WebFetch({
-  url: "http://localhost:4242/api/mastermind/event",
-  method: "POST",
-  headers: { "Content-Type": "application/json" },
-  body: JSON.stringify({
-    type: "session:start",
-    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()
-  })
-})
+### How to Emit (curl-first — WebFetch is blocked for localhost in Claude Code runtimes)
+
+**Always use curl via Bash.** WebFetch is restricted for `localhost` URLs in Claude Code agent runtimes and will return ECONNREFUSED even when the server is running. Use this pattern:
+
+```bash
+curl -s -o /dev/null -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg sid "$SESSION_ID" \
+    --arg type "session:start" \
+    --arg prompt "$resolved_prompt" \
+    --arg mode "$mode" \
+    --arg proj "$(pwd)" \
+    '{type:$type,session:$sid,prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-**If the server is not running** (WebFetch returns an error), log a warning and continue — event logging is non-blocking and MUST NOT abort the run.
+**Always append `|| true`** — event emission is non-blocking and MUST NOT abort the run.
+
+**If Bash is unavailable** (e.g. the agent type has no Bash tool): skip dashboard events entirely. They are observability-only and do not affect pipeline correctness. The master context always has Bash and emits session:start, domain:dispatch, and session:complete on behalf of the run.
 
 **Session ID:** Generate once at session:start and reuse across all subsequent events for this run. A simple ID format: `mm-<ISO8601-compact>` (e.g. `mm-20260505T142300`).
 
@@ -240,53 +247,78 @@ WebFetch({
 
 **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.
+
 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; }
+canonical="${project_name}-<domain>"
 
-# 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 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

@@ -105,6 +105,12 @@ COL_ELABORATED=$(echo "$columns"| jq -r '.[] | select(.title == "Elaborated") |
 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; }
 ```
 
 **After either branch above, validate and echo all values.** This is the canonical source for Step 4 Task construction.
@@ -173,7 +179,7 @@ echo "Selected specialists: $specialist_list"
 ```
 
 **CRITICAL — Variable substitution required before constructing the Task call:**
-The Task agent runs in an isolated context and cannot inherit shell variables. Before writing the Task prompt below, read the literal UUID values from the `=== IDEA BOARD LITERAL VALUES ===` echo block above and embed them as **hard-coded strings** in the prompt. Do NOT write `${BOARD_ID}`, `${COL_NEW}`, etc. in the prompt — the agent will receive those as literal dollar-sign strings and its `monotask card create` calls will fail, causing it to improvise with `monotask board create` and corrupt board names. Replace every `${BOARD_ID}`, `${COL_NEW}`, `${project_name}`, `${brain_context}`, `${prompt}`, `${date}`, and `${specialist_list}` with the actual value before calling Task.
+The Task agent runs in an isolated context and cannot inherit shell variables. Before writing the Task prompt below, read the literal UUID values from the `=== IDEA BOARD LITERAL VALUES ===` echo block above and embed them as **hard-coded strings** in the prompt. Do NOT write `${BOARD_ID}`, `${COL_NEW}`, etc. in the prompt — the agent will receive those as literal dollar-sign strings and its `monotask card create` calls will fail, causing it to improvise with `monotask board create` and corrupt board names. Replace every `${BOARD_ID}`, `${COL_NEW}`, `${project_name}`, `${brain_context}`, `${prompt}`, `${date}`, and `${specialist_list}` with the actual value before calling Task. Leave `$result`, `$CARD_ID`, and other loop-internal variables as-is — they are bash variables the agent itself will set at runtime, not substitution targets.
 
 Spawn the Idea Manager with `run_in_background: false` so its output is available for Step 5.
 
@@ -242,8 +248,8 @@ For each unique idea, create one card in the New column (COL_NEW = ${COL_NEW}):
 
   result=$(monotask card create "${BOARD_ID}" "${COL_NEW}" "<idea title ≤80 chars>" --json)
   CARD_ID=$(echo "$result" | jq -r '.id // empty')
-  monotask card comment add "${BOARD_ID}" "$CARD_ID" "DESCRIPTION: <2-3 sentence description>
-CATEGORY: <feature | technical-baseline | business-operation>
+  monotask card set-description "${BOARD_ID}" "$CARD_ID" "<2-3 sentence description>"
+  monotask card comment add "${BOARD_ID}" "$CARD_ID" "CATEGORY: <feature | technical-baseline | business-operation>
 SOURCE: <which specialist angle produced this>"
   monotask card label add "${BOARD_ID}" "$CARD_ID" "mastermind-idea"
   monotask card label add "${BOARD_ID}" "$CARD_ID" "category:<category>"
@@ -264,20 +270,29 @@ END_IDEAS_OUTPUT`
 })
 ```
 
-Parse the `IDEAS_OUTPUT` JSON block from the agent's response. If zero ideas were returned, report "Idea Manager produced no ideas." and STOP.
+Parse the `IDEAS_OUTPUT` JSON block from the agent's response and assign it:
+```bash
+ideas_output_json='<paste the JSON array from IDEAS_OUTPUT here>'
+```
+If zero ideas were returned, report "Idea Manager produced no ideas." and STOP.
 
 ---
 
 ### Step 5 — Validation (Product Manager Evaluation)
 
+**Build `ideas_list` before constructing the Step 5 Task prompt:**
+```bash
+# Format the full IDEAS_OUTPUT array (from Step 4) as the literal string to embed in the Task prompt.
+# Each line: card_id | title | description | category | source_angle
+ideas_list=$(echo "$ideas_output_json" | jq -r \
+  '.[] | "- card_id: \(.card_id)\n  title: \(.title)\n  description: \(.description)\n  category: \(.category)\n  source: \(.source_angle)\n"')
+```
+
 **CRITICAL — Variable substitution required for Step 5 Task call:**
-The PM agent runs in an isolated Task context and cannot inherit shell variables. Read the literal UUID values from the `=== IDEA BOARD LITERAL VALUES ===` echo block (Step 3) and embed them as hard-coded strings in the Task prompt. Do NOT pass `${BOARD_ID}`, `${COL_EVALUATED}`, `${COL_ICED}`, `${COL_REJECTED}` etc. — the agent will receive them as literal dollar-sign strings and its `monotask card move` / `monotask card set-impact` calls will silently fail.
+Before constructing the Task prompt below, read the literal UUID values from the `=== IDEA BOARD LITERAL VALUES ===` echo block (Step 3) and embed them as hard-coded strings. Also embed the full `brain_context`, `prompt`, and `ideas_list` (built above) as literal text. Replace every `${BOARD_ID}`, `${COL_EVALUATED}`, `${COL_ICED}`, `${COL_REJECTED}`, `${brain_context}`, `${prompt}`, `${project_name}`, `${date}`, and `${ideas_list}` with its actual value before calling Task — the agent receives unsubstituted `${...}` strings verbatim and silently skips every board update.
 
 Spawn a single `Product Manager` agent via the Task tool. The PM agent has Bash tool access and is responsible for both producing verdicts and executing all board updates directly.
 
-**CRITICAL — Variable substitution required for Step 5 Task call (same rule as Step 4):**
-Before constructing the Task prompt below, read the literal UUID values from the `=== IDEA BOARD LITERAL VALUES ===` echo block (Step 3) and embed them as hard-coded strings. Also embed the full `brain_context`, `prompt`, and the entire ideas list (with card IDs) as literal text. Do NOT write `${BOARD_ID}`, `${COL_EVALUATED}`, `${brain_context}`, etc. — the agent receives them as literal dollar-sign strings and silently skips every board update.
-
 ```javascript
 Task({
   subagent_type: "Product Manager",
@@ -347,7 +362,11 @@ END_VERDICTS_OUTPUT`
 })
 ```
 
-After the PM agent completes, parse the `VERDICTS_OUTPUT` block from the agent's response (schema is embedded in the Task prompt above). If **all** ideas are iced or rejected, output a summary table and STOP — skip Steps 6–7.
+After the PM agent completes, parse the `VERDICTS_OUTPUT` block from the agent's response and assign it:
+```bash
+verdicts_output_json='<paste the JSON array from VERDICTS_OUTPUT here>'
+```
+This variable is used throughout Steps 6a and 6c to build idea lists, registry keywords, and inherit impact/effort scores — it must be set before proceeding. If **all** ideas are iced or rejected, output a summary table and STOP — skip Steps 6–7.
 
 ---
 
@@ -355,16 +374,29 @@ After the PM agent completes, parse the `VERDICTS_OUTPUT` block from the agent's
 
 #### 6a. Elaboration (conditional)
 
-For any evaluated idea with `skipElaboration: true`, move it directly to `Elaborated` and write a rationale comment so future readers understand why no deep elaboration was needed:
+For any evaluated idea with `skipElaboration: true`, move it directly to `Elaborated`, set a description, and write a rationale comment so future readers understand why no deep elaboration was needed:
 ```bash
+monotask card set-description "$BOARD_ID" "$CARD_ID" "Elaboration skipped — PM assessed this as straightforward.\n\nRationale: <rationale from VERDICTS_OUTPUT for this card_id>\n\nImpact: <impact>/10 | Effort: <effort>/10"
 monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ELABORATED" --json
 monotask card comment add "$BOARD_ID" "$CARD_ID" "Elaboration skipped: PM assessed this idea as straightforward with no significant unknowns. Rationale: <rationale from VERDICTS_OUTPUT for this card_id>"
 ```
 
 For ideas with `skipElaboration: false`, **split by category** before spawning agents:
 
+**Build `dev_ideas_list` and `ops_ideas_list` before constructing the Step 6a Task prompts:**
+```bash
+# Filter VERDICTS_OUTPUT (parsed in Step 5) by category and format as literal text.
+dev_ideas_list=$(echo "$verdicts_output_json" | jq -r \
+  '.[] | select(.verdict == "evaluated") | select(.category == "feature" or .category == "technical-baseline") |
+   "- card_id: \(.card_id)\n  title: \(.title)\n  category: \(.category)\n  rationale: \(.rationale)\n"')
+
+ops_ideas_list=$(echo "$verdicts_output_json" | jq -r \
+  '.[] | select(.verdict == "evaluated") | select(.category == "business-operation") |
+   "- card_id: \(.card_id)\n  title: \(.title)\n  category: \(.category)\n  rationale: \(.rationale)\n"')
+```
+
 **CRITICAL — Variable substitution required for Step 6a Task calls:**
-Elaboration agents run in isolated Task contexts. Before constructing each Task prompt, replace every `${brain_context}`, `${dev_ideas_list}`, and `${ops_ideas_list}` with the actual literal text — `brain_context` from the brain load, `dev_ideas_list` and `ops_ideas_list` from the IDEAS_OUTPUT/VERDICTS_OUTPUT parsed in Steps 4–5 (filter by category). Do NOT leave any `${...}` placeholders in the prompt — the agent receives them as literal dollar-sign strings and produces empty ELABORATION_OUTPUT blocks.
+Elaboration agents run in isolated Task contexts. Before constructing each Task prompt, replace every `${brain_context}`, `${dev_ideas_list}`, and `${ops_ideas_list}` with the actual literal text — `brain_context` from the brain load, `dev_ideas_list` and `ops_ideas_list` built above. Do NOT leave any `${...}` placeholders in the prompt — the agent receives them as literal dollar-sign strings and produces empty ELABORATION_OUTPUT blocks.
 
 **Dev ideas** (`feature` or `technical-baseline`):
 Spawn two agents in parallel via Task tool:
@@ -484,42 +516,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)
-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"))
+```
 
-### Dev ideas — Edge cases & prior art:
-<researcher findings>
+Use process substitution (not a pipeline) so the while loop runs in the main shell and variables remain in scope after `done`:
 
-### Dev ideas — Codebase constraints:
-<code-explorer findings>"
+```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')
 
-# OR for business-operation ideas:
-monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
+  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>"
-
-# 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>"
+$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
+
+### Codebase constraints:
+$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
@@ -528,6 +599,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:
 
 ```
@@ -580,8 +655,9 @@ After applying all user instructions, proceed to Step 6c with the remaining idea
 REGISTRY=".monomind/registry.json"
 
 # Dev decomposition agent — pick the most relevant engineering/architecture specialist
-# Use the idea titles and descriptions as the keyword signal
-DEV_IDEA_CONTEXT="<concatenated titles+descriptions of all dev ideas>"
+# Build keyword signal from elaborated dev idea titles (from VERDICTS_OUTPUT filtered above)
+DEV_IDEA_CONTEXT=$(echo "$verdicts_output_json" | jq -r \
+  '[.[] | select(.verdict=="evaluated") | select(.category=="feature" or .category=="technical-baseline") | .title] | join(" ")')
 dev_decomp_agent=$(jq -r \
   --arg kw "$(echo "$DEV_IDEA_CONTEXT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')" \
   '[ .agents[] | select(.deprecated != true)
@@ -601,7 +677,8 @@ dev_decomp_agent=$(jq -r \
 dev_decomp_agent="${dev_decomp_agent:-Software Architect}"
 
 # Ops decomposition agent — pick the most relevant strategy/sales/product specialist
-OPS_IDEA_CONTEXT="<concatenated titles+descriptions of all ops ideas>"
+OPS_IDEA_CONTEXT=$(echo "$verdicts_output_json" | jq -r \
+  '[.[] | select(.verdict=="evaluated") | select(.category=="business-operation") | .title] | join(" ")')
 ops_decomp_agent=$(jq -r \
   --arg kw "$(echo "$OPS_IDEA_CONTEXT" | tr '[:upper:]' '[:lower:]' | grep -oE '[a-z]{5,}' | sort -u | tr '\n' ' ')" \
   '[ .agents[] | select(.deprecated != true)
@@ -624,30 +701,88 @@ echo "Dev decomp: $dev_decomp_agent | Ops decomp: $ops_decomp_agent"
 ```
 
 **CRITICAL — Variable substitution required for Step 6c Task calls:**
-Decomposition agents also run in isolated Task contexts. Before constructing each Task prompt, embed the literal card IDs (from the elaborated ideas list), `brain_context`, and `prompt` as hard-coded strings. Do NOT write `${card_id}`, `${brain_context}`, etc. as template placeholders.
+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:
 
-Each decomposition agent's Task prompt should begin with:
-> `SAFETY CHECK: You are a decomposition agent. You must NOT call monotask board create, space create, or column create. Your only job is producing a TASKS_OUTPUT block — the outer skill creates the cards. If you are unsure of any card ID, list it as "UNKNOWN" rather than inventing a value.`
+```bash
+# Build elaborated idea lists including card comments (full context for decomposition agents)
+dev_ideas_elaborated=$(echo "$verdicts_output_json" | jq -r \
+  '[.[] | select(.verdict=="evaluated") | select(.category=="feature" or .category=="technical-baseline") |
+   "card_id: \(.card_id)\ntitle: \(.title)\ncategory: \(.category)\nrationale: \(.rationale)\nimpact: \(.impact) effort: \(.effort)"] | join("\n\n")')
+
+ops_ideas_elaborated=$(echo "$verdicts_output_json" | jq -r \
+  '[.[] | select(.verdict=="evaluated") | select(.category=="business-operation") |
+   "card_id: \(.card_id)\ntitle: \(.title)\ncategory: \(.category)\nrationale: \(.rationale)\nimpact: \(.impact) effort: \(.effort)"] | join("\n\n")')
+```
 
 **Spawn decomposition agents by track** — run both in parallel if both tracks have elaborated ideas:
 
-- For **dev ideas** (`feature` or `technical-baseline`): spawn the agent selected as `$dev_decomp_agent`.
-- For **business-operation ideas**: spawn the agent selected as `$ops_decomp_agent`.
+```javascript
+// Dev decomposition agent (only if dev_ideas_elaborated is non-empty)
+Task({
+  subagent_type: dev_decomp_agent,  // value from registry selection above
+  description: "Task decomposition: dev ideas for " + project_name,
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are a decomposition agent. You must NOT call monotask board create, space create, or column create. Your only job is producing a TASKS_OUTPUT block — the outer skill creates the cards. If you are unsure of any card ID, list it as "UNKNOWN" rather than inventing a value.
 
-Provide each agent with:
-- Their subset of elaborated ideas (titles, descriptions, all card comments, literal card IDs, and category)
-- The literal `brain_context` and `prompt` values
+Decompose the following dev ideas into concrete subtasks (2–6 per idea). Each subtask should be independently implementable.
 
-Each agent must output a `TASKS_OUTPUT` block. For each elaborated idea, produce 2–6 subtasks. If an idea's scope is unclear, flag it instead of decomposing.
+PROJECT: ${project_name}
+GOAL: ${prompt}
+
+BRAIN CONTEXT:
+${brain_context}
+
+DEV IDEAS TO DECOMPOSE:
+${dev_ideas_elaborated}
+
+For each idea, produce 2–6 subtasks. If an idea's scope is unclear, flag it in FLAGGED instead of decomposing.
 
-```
 TASKS_OUTPUT
 [
   {
-    "parent_card_id": "<ideation board card ID>",
+    "parent_card_id": "<ideation board card ID from the list above>",
     "title": "<subtask title ≤80 chars>",
-    "description": "<what to build/do>",
-    "category": "feature | technical-baseline | business-operation",
+    "description": "<what to build/do — specific and actionable>",
+    "category": "feature | technical-baseline",
+    "agent": "<recommended subagent_type>",
+    "effort": <1-10>,
+    "has_prerequisites": <true | false>
+  }
+]
+FLAGGED
+[
+  { "card_id": "<ideation card ID>", "question": "<what needs clarifying>" }
+]
+END_TASKS_OUTPUT`
+})
+
+// Ops decomposition agent (only if ops_ideas_elaborated is non-empty)
+Task({
+  subagent_type: ops_decomp_agent,  // value from registry selection above
+  description: "Task decomposition: ops ideas for " + project_name,
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are a decomposition agent. You must NOT call monotask board create, space create, or column create. Your only job is producing a TASKS_OUTPUT block — the outer skill creates the cards. If you are unsure of any card ID, list it as "UNKNOWN" rather than inventing a value.
+
+Decompose the following business-operation ideas into concrete subtasks (2–6 per idea). Each subtask should be independently actionable.
+
+PROJECT: ${project_name}
+GOAL: ${prompt}
+
+BRAIN CONTEXT:
+${brain_context}
+
+OPS IDEAS TO DECOMPOSE:
+${ops_ideas_elaborated}
+
+For each idea, produce 2–6 subtasks. If an idea's scope is unclear, flag it in FLAGGED instead of decomposing.
+
+TASKS_OUTPUT
+[
+  {
+    "parent_card_id": "<ideation board card ID from the list above>",
+    "title": "<subtask title ≤80 chars>",
+    "description": "<what to build/do — specific and actionable>",
+    "category": "business-operation",
     "agent": "<recommended subagent_type>",
     "effort": <1-10>,
     "has_prerequisites": <true | false>
@@ -657,7 +792,8 @@ FLAGGED
 [
   { "card_id": "<ideation card ID>", "question": "<what needs clarifying>" }
 ]
-END_TASKS_OUTPUT
+END_TASKS_OUTPUT`
+})
 ```
 
 **After both decomposition agents return**, the outer skill creates task cards on the appropriate board for each task's category. Each task card inherits the parent idea's `impact` and `effort` scores from the VERDICTS_OUTPUT parsed in Step 5 — look up by `parent_card_id`.
@@ -680,11 +816,14 @@ monotask column create "$TASK_BOARD_ID" "Human in Loop" --json >/dev/null
 monotask column create "$TASK_BOARD_ID" "Done"          --json >/dev/null
 ```
 
-Look up column IDs:
+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; }
 ```
 
 ---
@@ -705,19 +844,43 @@ monotask column create "$OPS_BOARD_ID" "Human in Loop" --json >/dev/null
 monotask column create "$OPS_BOARD_ID" "Done"          --json >/dev/null
 ```
 
-Look up column IDs:
+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; }
 ```
 
 ---
 
-**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"
@@ -727,14 +890,20 @@ else
   BOARD_LABEL="Implementation Tasks"
 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 // 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>
 TASK_CARD_ID=$(monotask card subtask add "$BOARD_ID" "$parent_card_id" "$TARGET_BOARD" "$COL_TARGET" "<task title>" --json | jq -r '.id')
 # Set the task description as the primary content field
 monotask card set-description "$TARGET_BOARD" "$TASK_CARD_ID" "<what to build/do — from TASKS_OUTPUT description>"
-# Inherit impact and effort from parent idea (looked up from VERDICTS_OUTPUT by parent_card_id)
-monotask card set-impact "$TARGET_BOARD" "$TASK_CARD_ID" <parent_impact>
-monotask card set-effort "$TARGET_BOARD" "$TASK_CARD_ID" <parent_effort>
+monotask card set-impact "$TARGET_BOARD" "$TASK_CARD_ID" "$parent_impact"
+monotask card set-effort "$TARGET_BOARD" "$TASK_CARD_ID" "$parent_effort"
 monotask card comment add "$TARGET_BOARD" "$TASK_CARD_ID" \
   "SOURCE: mastermind:idea | <first 100 chars of prompt>
 AGENT: <agent>
@@ -743,14 +912,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.14",
+  "version": "1.9.16",
   "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",