@monoes/monomindcli 1.9.14 → 1.9.15

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
@@ -251,8 +253,12 @@ jq --arg domains "$domains_needed" \
 
 ### 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`).
 

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

@@ -173,7 +173,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 +242,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 +264,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 +356,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 +368,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:
@@ -488,22 +514,24 @@ After all agents complete, merge their outputs per idea (same card_id → concat
 
 ```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
-
-### Dev ideas — Edge cases & prior art:
-<researcher findings>
-
-### Dev ideas — Codebase constraints:
-<code-explorer findings>"
-
-# OR for business-operation ideas:
-monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
+if [ "$category" = "business-operation" ]; then
+  monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
 
 ### Industry context & benchmarks:
 <researcher findings>
 
 ### Feasibility & stakeholder impact:
 <PM findings>"
+else
+  # feature or technical-baseline
+  monotask card set-description "$BOARD_ID" "$CARD_ID" "## Elaboration Findings
+
+### Edge cases & prior art:
+<researcher findings>
+
+### Codebase constraints:
+<code-explorer findings>"
+fi
 
 # Also add each finding as a comment for traceability
 # Dev ideas:
@@ -580,8 +608,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 +630,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 +654,49 @@ 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}`, and `${dev_ideas_elaborated}` / `${ops_ideas_elaborated}` with actual literal text. 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>
@@ -657,7 +706,47 @@ FLAGGED
 [
   { "card_id": "<ideation card ID>", "question": "<what needs clarifying>" }
 ]
-END_TASKS_OUTPUT
+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>
+  }
+]
+FLAGGED
+[
+  { "card_id": "<ideation card ID>", "question": "<what needs clarifying>" }
+]
+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 +769,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,11 +797,14 @@ 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; }
 ```
 
 ---
@@ -727,14 +822,17 @@ 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')
+parent_effort=$(echo "$verdicts_output_json" | jq -r --arg id "$parent_card_id" '.[] | select(.card_id == $id) | .effort')
+
 # 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>

package/package.json

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