@monoes/monomindcli 1.9.13 → 1.9.15

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,56 +264,81 @@ 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)
 
-**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.
+**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"')
+```
 
-Begin the PM agent's Task prompt with this safety check:
-> `SAFETY CHECK: Verify that the BOARD_ID you received matches UUID format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. If it does not, STOP and report "ERROR: BOARD_ID not substituted — received: <value>". Do NOT call monotask board create, space create, or any board/space management commands. Your job is updating existing CARDS only.`
+**CRITICAL — Variable substitution required for Step 5 Task call:**
+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.
 
-Provide the PM agent with:
-- All ideas from Step 4 (titles, descriptions, categories, card IDs, and the literal UUID values for BOARD_ID, COL_EVALUATED, COL_ICED, COL_REJECTED from the Step 3 echo block)
-- The `brain_context`
-- The original `prompt`
+```javascript
+Task({
+  subagent_type: "Product Manager",
+  description: "PM validation for project " + project_name,
+  run_in_background: false,
+  prompt: `SAFETY CHECK: Verify that the BOARD_ID you received matches UUID format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12 hex chars). If it does not, STOP and report "ERROR: BOARD_ID not substituted — received: <value>". Do NOT call monotask board create, space create, or column create. Your only job is evaluating cards and running impact/effort updates on existing cards.
 
-The PM agent must, for **each idea**, determine one verdict plus **impact** (0–10) and **effort** (0–10) scores:
+You are the Product Manager evaluator for project "${project_name}".
 
-| Verdict | Criteria |
-|---------|----------|
-| **evaluated** | Worth pursuing. Set a `skipElaboration` boolean (`true` = straightforward, no deep research needed; `false` = edge cases should be explored). Include a 1-2 sentence value statement. |
-| **iced** | Good potential but needs a question answered first. Include the blocking question. |
-| **rejected** | Out of scope, infeasible, or low value. Include a 1-sentence reason. |
+CONTEXT: ${date} | Project: ${project_name}
+ORIGINAL GOAL: ${prompt}
 
-The PM agent must run these board updates directly using Bash tool:
+BRAIN CONTEXT:
+${brain_context}
 
-```bash
-# evaluated
-monotask card move "$BOARD_ID" "$CARD_ID" "$COL_EVALUATED" --json
-monotask card set-impact "$BOARD_ID" "$CARD_ID" <0-10>
-monotask card set-effort "$BOARD_ID" "$CARD_ID" <0-10>
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Value: <value statement>"
+YOUR BOARD: ${BOARD_ID}
+COL_EVALUATED: ${COL_EVALUATED}
+COL_ICED:      ${COL_ICED}
+COL_REJECTED:  ${COL_REJECTED}
 
-# iced
-monotask card move "$BOARD_ID" "$CARD_ID" "$COL_ICED" --json
-monotask card set-impact "$BOARD_ID" "$CARD_ID" <0-10>
-monotask card set-effort "$BOARD_ID" "$CARD_ID" <0-10>
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Blocked: <question>"
+IDEAS TO EVALUATE (formatted from IDEAS_OUTPUT parsed in Step 4 — paste the full JSON array here as literal text):
+${ideas_list}
 
-# rejected
-monotask card move "$BOARD_ID" "$CARD_ID" "$COL_REJECTED" --json
-monotask card comment add "$BOARD_ID" "$CARD_ID" "Rejected: <reason>"
-```
+For EVERY idea above, determine:
+- verdict: evaluated | iced | rejected
+- impact: 0–10 (business value / strategic importance)
+- effort: 0–10 (implementation cost / complexity)
+- skipElaboration: true (simple, no deep research needed) | false (edge cases should be explored) — only for evaluated
+- rationale: 1-2 sentence value statement (evaluated), blocking question (iced), or rejection reason (rejected)
 
-The PM agent must also output a structured block so the outer skill can proceed:
+MANDATORY BOARD UPDATES — run these bash commands for EVERY idea, no exceptions:
+
+For evaluated ideas:
+  monotask card move "${BOARD_ID}" "<CARD_ID>" "${COL_EVALUATED}" --json
+  monotask card set-impact "${BOARD_ID}" "<CARD_ID>" <impact>
+  monotask card set-effort "${BOARD_ID}" "<CARD_ID>" <effort>
+  monotask card comment add "${BOARD_ID}" "<CARD_ID>" "Value: <rationale>"
+
+For iced ideas:
+  monotask card move "${BOARD_ID}" "<CARD_ID>" "${COL_ICED}" --json
+  monotask card set-impact "${BOARD_ID}" "<CARD_ID>" <impact>
+  monotask card set-effort "${BOARD_ID}" "<CARD_ID>" <effort>
+  monotask card comment add "${BOARD_ID}" "<CARD_ID>" "Blocked: <blocking question>"
+
+For rejected ideas:
+  monotask card move "${BOARD_ID}" "<CARD_ID>" "${COL_REJECTED}" --json
+  monotask card comment add "${BOARD_ID}" "<CARD_ID>" "Rejected: <reason>"
+
+IMPORTANT: set-impact and set-effort MUST be called for every evaluated and iced idea. Do not skip them.
+
+After completing all board updates, output this structured block:
 
-```
 VERDICTS_OUTPUT
 [
   {
@@ -322,15 +347,20 @@ VERDICTS_OUTPUT
     "category": "feature | technical-baseline | business-operation",
     "verdict": "evaluated | iced | rejected",
     "skipElaboration": true | false,
-    "rationale": "<value statement (if evaluated) | blocking question (if iced) | rejection reason (if rejected)>",
+    "rationale": "<value statement | blocking question | rejection reason>",
     "impact": <0-10>,
     "effort": <0-10>
   }
 ]
-END_VERDICTS_OUTPUT
+END_VERDICTS_OUTPUT`
+})
 ```
 
-After the PM agent completes, parse `VERDICTS_OUTPUT`. 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.
 
 ---
 
@@ -338,43 +368,172 @@ After the PM agent completes, parse `VERDICTS_OUTPUT`. If **all** ideas are iced
 
 #### 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` 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:
-1. `feature-dev:code-explorer` — traces execution paths, maps dependencies, surfaces codebase constraints relevant to each idea.
-2. `researcher` (with WebSearch) — finds prior art, edge cases, implementation pitfalls for each idea.
+Spawn two agents in parallel via Task tool:
 
-**Business-operation ideas** (`business-operation`):
-Spawn two agents in parallel:
-1. `researcher` (with WebSearch) — finds industry benchmarks, comparable operational processes, known pitfalls, and market context.
-2. `Product Manager` — assesses process feasibility, stakeholder impact, alignment with existing workflows, and resource requirements.
+```javascript
+// Agent 1 — code explorer
+Task({
+  subagent_type: "feature-dev:code-explorer",
+  description: "Elaboration: codebase constraints for dev ideas",
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are an elaboration agent. Do NOT call monotask board create, space create, or column create. Your only job is producing an ELABORATION_OUTPUT block — the outer skill writes to the board.
+
+Analyze the following dev ideas against the current codebase. For each idea, trace relevant execution paths, map dependencies, and surface constraints or implementation risks.
+
+BRAIN CONTEXT:
+${brain_context}
+
+IDEAS:
+${dev_ideas_list}
 
-Provide all agents with: their subset of ideas (titles, descriptions, card IDs) + `brain_context`.
+Output this block:
+ELABORATION_OUTPUT
+[
+  {
+    "card_id": "<idea card ID>",
+    "findings": "<detailed codebase constraints, dependency risks, and implementation notes>",
+    "blocking_issue": "<blocking issue if any, or null>"
+  }
+]
+END_ELABORATION_OUTPUT`
+})
+
+// Agent 2 — researcher
+Task({
+  subagent_type: "researcher",
+  description: "Elaboration: prior art and edge cases for dev ideas",
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are an elaboration agent. Do NOT call monotask board create, space create, or column create. Your only job is producing an ELABORATION_OUTPUT block — the outer skill writes to the board.
+
+Research the following dev ideas. For each idea, find prior art, known edge cases, implementation pitfalls, and relevant open-source approaches.
+
+BRAIN CONTEXT:
+${brain_context}
 
-Each agent must output their findings in this format:
+IDEAS:
+${dev_ideas_list}
+
+Output this block:
+ELABORATION_OUTPUT
+[
+  {
+    "card_id": "<idea card ID>",
+    "findings": "<prior art, edge cases, pitfalls, and relevant examples>",
+    "blocking_issue": "<blocking issue if any, or null>"
+  }
+]
+END_ELABORATION_OUTPUT`
+})
 ```
+
+**Business-operation ideas** (`business-operation`):
+Spawn two agents in parallel via Task tool:
+
+```javascript
+// Agent 1 — researcher
+Task({
+  subagent_type: "researcher",
+  description: "Elaboration: industry benchmarks for ops ideas",
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are an elaboration agent. Do NOT call monotask board create, space create, or column create. Your only job is producing an ELABORATION_OUTPUT block — the outer skill writes to the board.
+
+Research the following business-operation ideas. For each idea, find industry benchmarks, comparable operational processes, known pitfalls, and market context.
+
+BRAIN CONTEXT:
+${brain_context}
+
+IDEAS:
+${ops_ideas_list}
+
+Output this block:
 ELABORATION_OUTPUT
 [
   {
     "card_id": "<idea card ID>",
-    "findings": "<detailed findings for this idea>",
+    "findings": "<industry benchmarks, comparable processes, pitfalls, and market context>",
     "blocking_issue": "<blocking issue if any, or null>"
   }
 ]
-END_ELABORATION_OUTPUT
+END_ELABORATION_OUTPUT`
+})
+
+// Agent 2 — Product Manager
+Task({
+  subagent_type: "Product Manager",
+  description: "Elaboration: feasibility assessment for ops ideas",
+  run_in_background: true,
+  prompt: `SAFETY CHECK: You are an elaboration agent. Do NOT call monotask board create, space create, or column create. Your only job is producing an ELABORATION_OUTPUT block — the outer skill writes to the board.
+
+Assess the following business-operation ideas for process feasibility, stakeholder impact, alignment with existing workflows, and resource requirements.
+
+BRAIN CONTEXT:
+${brain_context}
+
+IDEAS:
+${ops_ideas_list}
+
+Output this block:
+ELABORATION_OUTPUT
+[
+  {
+    "card_id": "<idea card ID>",
+    "findings": "<feasibility assessment, stakeholder impact, workflow alignment, resource needs>",
+    "blocking_issue": "<blocking issue if any, or null>"
+  }
+]
+END_ELABORATION_OUTPUT`
+})
 ```
 
-After all agents complete, merge their outputs per idea (same card_id → concatenate findings). For each idea:
+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:
 
 ```bash
-# Write merged findings as card comments
+# 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
+
+### 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:
 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>"
@@ -449,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)
@@ -470,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)
@@ -493,30 +654,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}`, 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>
+  }
+]
+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>
@@ -526,7 +745,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`.
@@ -549,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; }
 ```
 
 ---
@@ -574,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; }
 ```
 
 ---
@@ -596,10 +822,17 @@ else
   BOARD_LABEL="Implementation Tasks"
 fi
 
-TASK_CARD_ID=$(monotask card create "$TARGET_BOARD" "$COL_TARGET" "<task title>" --json | jq -r '.id')
-# 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>
+# 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>"
+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/dist/src/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AA62B1E,eAAO,MAAM,WAAW,EAAE,OAkFzB,CAAC;AAEF,eAAe,WAAW,CAAC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAk3B1E,eAAO,MAAM,WAAW,EAAE,OAkFzB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/src/commands/init.js

@@ -234,13 +234,18 @@ const initAction = async (ctx) => {
                 options.components.settings ? `Review ${output.highlight('.claude/settings.json')} for hook configurations` : '',
             ].filter(Boolean));
         }
-        // Recommend UA semantic enrichment
+        // Recommend semantic enrichment — prominent callout, not buried tip
         output.writeln('');
-        output.writeln(output.bold('Tip: Enrich your knowledge graph with semantic summaries'));
-        output.writeln(output.dim('  Run /monomind:understand in Claude Code to analyze your project'));
-        output.writeln(output.dim('  and add LLM-generated summaries, tags, and architectural layers'));
-        output.writeln(output.dim(`  to the monograph graph. This gives Claude Code a richer mental`));
-        output.writeln(output.dim(`  model of your codebase from the very first session.`));
+        output.writeln(output.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        output.writeln(output.bold('  Run /monomind:understand next'));
+        output.writeln('');
+        output.writeln('  In Claude Code, type:  /monomind:understand');
+        output.writeln('');
+        output.writeln('  This analyzes your project with an LLM and enriches the');
+        output.writeln('  knowledge graph with semantic summaries, tags, and layers.');
+        output.writeln('  Claude Code will have a much richer mental model of your');
+        output.writeln('  codebase from the very first session.');
+        output.writeln(output.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
         if (ctx.flags.format === 'json') {
             output.printJson(result);
         }