monomind 1.11.13 → 1.12.0

package/.claude/skills/mastermind/createorg.md

@@ -401,8 +401,8 @@ space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$org_name" '$2==
 [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$org_name' — verify monotask is installed (run: monotask --version)"; exit 1; }
 
 # Step 2 — Board (created only after space is confirmed)
-board_id=$(monotask board create "org-tasks" --json 2>/dev/null | jq -r '.id // empty')
-[ -z "$board_id" ] && echo "[createorg] monotask board unavailable — board tracking skipped."
+board_id=$(monotask board create "org-tasks" --json | jq -r '.id // empty')
+[ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board"; exit 1; }
 
 # Step 3 — Link board to space immediately
 monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true

package/.claude/skills/mastermind/finance.md

@@ -51,8 +51,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "finance" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[finance] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "finance" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create finance 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')
@@ -116,7 +116,7 @@ Spawn one Task agent per workstream:
 - Financial tracking and invoicing: subagent_type "Finance Tracker"
 - Analysis and reporting: subagent_type "Analytics Reporter"
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Collect all financial outputs. Return to caller:

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

@@ -9,13 +9,15 @@ default_mode: confirm
 
 This skill is invoked by `mastermind:master` or directly via `/mastermind:idea`.
 
-**Extract `--monotask` flag:** If present in `$ARGUMENTS`, set `USE_MONOTASK=true` and remove it. Default: `USE_MONOTASK=false`.
+**Extract `--monotask` flag:** If present in `$ARGUMENTS`, set `USE_MONOTASK=true` and remove it from `$ARGUMENTS`. Default: `USE_MONOTASK=false`.
 
 **File mode (default, `USE_MONOTASK=false`):**
 
-Invoke `Skill("mastermind:ideate", $ARGUMENTS)` immediately — it provides the same research, evaluation, elaboration, and task-decomposition pipeline with file-first storage (`docs/ideas/` and `docs/tasks/`). The rest of this skill only runs in monotask mode.
+Invoke `Skill("mastermind:ideate", $ARGUMENTS)` immediately — it provides the same research, evaluation, elaboration, and task-decomposition pipeline with file-first storage (`docs/ideas/` and `docs/tasks/`). The rest of this skill is skipped in file mode.
 
-**Monotask mode (`USE_MONOTASK=true` only):** Continue with the steps below.
+**Board mode (`USE_MONOTASK=true`):**
+
+Continue with the full monotask board pipeline below (Steps 3-6).
 
 ---
 

package/.claude/skills/mastermind/marketing.md

@@ -97,8 +97,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "marketing" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[marketing] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "marketing" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create marketing 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')
@@ -172,7 +172,7 @@ Spawn one Task agent per workstream (all in parallel — star topology, hub aggr
 - Product launch / GTM: subagent_type "Launch Strategist" (slug: launch-strategist)
 - Competitive content / comparison pages: subagent_type "Competitive Content Strategist" (slug: competitive-content)
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Collect all agent outputs. Return to caller:

package/.claude/skills/mastermind/monitor.md

@@ -1128,7 +1128,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
       "type": "linear",
       "filter": {
         "team": "ENG",
-        "assignees": ["morteza@agent-f.com"],
+        "assignees": ["your@email.com"],
         "states": ["Todo"],
         "labels": ["ai-agent"],
         "project": ""
@@ -1219,7 +1219,7 @@ If `caller` is not "command", follow `_protocol.md` Brain Write Procedure for do
 
 # Add a Linear source to an existing monitor
 /mastermind:monitor --action add-source --name dev-watcher \
-  --source linear --team ENG --user morteza@agent-f.com \
+  --source linear --team ENG --user your@email.com \
   --state Todo --label ai-agent
 
 # Add a monotask board source

package/.claude/skills/mastermind/release.md

@@ -51,8 +51,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "release" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[release] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "release" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create release 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')
@@ -118,7 +118,7 @@ Spawn Task agents in release order (hierarchical raft — coordinator maintains
 - Infrastructure and deploy: subagent_type "DevOps Automator"
 - CI/CD pipeline: subagent_type "cicd-engineer"
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Collect all stage outcomes. Return to caller:

package/.claude/skills/mastermind/research.md

@@ -51,8 +51,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "research" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[research] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "research" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create research 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')
@@ -118,7 +118,7 @@ Spawn one Task agent per research stream (mesh topology — findings cross-polli
 - User behavior and UX signals: subagent_type "UX Researcher"
 - Data and metrics analysis: subagent_type "Analytics Reporter"
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Synthesize all research streams into an intelligence report. Return to caller:

package/.claude/skills/mastermind/review.md

@@ -62,8 +62,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "review" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[review] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "review" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create review 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')
@@ -169,7 +169,7 @@ Step 4 — Report:
   MISSES: representative samples that return safe=true but contain injection patterns
 ```
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Synthesize all review findings. Return to caller:

package/.claude/skills/mastermind/runorg.md

@@ -244,9 +244,10 @@ runId              = new Date().toISOString()
 
 Also validate that every role has non-empty `id`, `title`, `agent_type`, and `responsibilities` (array). Abort with `status: blocked` listing any malformed role — do this before Step 3 initializes infrastructure.
 
-After the conceptual derivations above, extract them as real shell variables so downstream bash blocks can reference `$orgName`, `$sessionId`, etc.:
+After the conceptual derivations above, **run the ENTIRE Step 2 + Step 3 setup as a SINGLE Bash tool call** so all variables persist through infrastructure creation. Copy the full script below into one Bash call — do NOT split it across multiple calls:
 
 ```bash
+# ── STEP 2+3 COMBINED (must run as one Bash call — variables must persist) ──
 orgFile=".monomind/orgs/${org_name}.json"
 orgName=$(jq -r '.name' "$orgFile")
 goal="${task:-$(jq -r '.goal' "$orgFile")}"
@@ -266,71 +267,73 @@ board_id=$(jq -r '.board_id // empty' "$orgFile")
 todo_col=$(jq -r '.todo_col_id // empty' "$orgFile")
 doing_col=$(jq -r '.doing_col_id // empty' "$orgFile")
 done_col=$(jq -r '.done_col_id // empty' "$orgFile")
-runId=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-```
-
----
-
-## Step 3 — Initialize Org Infrastructure
-
-**Validate board IDs from org config:**
-
-The board and column IDs were written into the org config by `createorg`. If missing, the org was not created correctly.
+runId="run-$(date -u +%Y%m%dT%H%M%S)"
 
-```bash
-[ -z "$board_id" ]  && { echo "ERROR: org config missing board_id — re-run /mastermind:createorg --name ${orgName} to rebuild the org."; exit 1; }
-[ -z "$todo_col" ]  && { echo "ERROR: org config missing todo_col_id — re-run /mastermind:createorg --name ${orgName}."; exit 1; }
-[ -z "$doing_col" ] && { echo "ERROR: org config missing doing_col_id — re-run /mastermind:createorg --name ${orgName}."; exit 1; }
-[ -z "$done_col" ]  && { echo "ERROR: org config missing done_col_id — re-run /mastermind:createorg --name ${orgName}."; exit 1; }
-```
+# Validate board IDs (warning only — boss can still scan/fix code without a board)
+[ -z "$board_id" ] && echo "WARN: board_id missing from org config — task board commands will be skipped by boss"
 
-**Create stop-file and state directories:**
-```bash
+# Remove any stale stop file (MUST happen before boss spawns)
 mkdir -p .monomind/orgs/.stops
-```
+rm -f "$stopFile"
 
-**Initialize org state file** (tracks per-agent status, heartbeat timestamps, token usage):
-```bash
+# Initialize org state file
 stateFile=".monomind/orgs/${orgName}-state.json"
 if [ ! -f "$stateFile" ]; then
-  jq -n \
-    --arg org "$orgName" \
-    --arg runId "$runId" \
-    '{org:$org,run_id:$runId,started_at:(now|todate),agents:{}}' \
-    > "$stateFile"
+  jq -n --arg org "$orgName" --arg runId "$runId" \
+    '{org:$org,run_id:$runId,started_at:(now|todate),agents:{}}' > "$stateFile"
 else
-  # Update run_id and started_at for this run
   tmp="${stateFile}.tmp"
-  jq --arg runId "$runId" \
-     '.run_id = $runId | .started_at = (now|todate)' \
-     "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
+  jq --arg runId "$runId" '.run_id = $runId | .started_at = (now|todate)' \
+    "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
 fi
-```
 
-**Remove any stale stop file:**
-```bash
-rm -f "$stopFile"
+# Resolve git-safe monomind directory
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || echo ".git")
+if [[ "$GIT_COMMON" != /* ]]; then GIT_COMMON="$REPO_ROOT/$GIT_COMMON"; fi
+GIT_COMMON="${GIT_COMMON%/}"
+MONO_DIR="${GIT_COMMON}/monomind"
+
+# Create run file and write run:start
+runDir="${MONO_DIR}/orgs/${orgName}/runs"
+mkdir -p "$runDir"
+runFile="${runDir}/${runId}.jsonl"
+jq -cn \
+  --arg runId "$runId" --arg org "$orgName" --arg goal "$goal" \
+  --arg bossRole "$bossRole_id" --arg proj "$REPO_ROOT" \
+  '{type:"run:start",runId:$runId,org:$org,orgName:$org,goal:$goal,bossRole:$bossRole,project:$proj,ts:(now*1000|floor)}' \
+  >> "$runFile"
+
+# Print resolved values so Step 4 can embed them in the boss prompt
+echo "ORG_VARS: orgName=${orgName} runId=${runId} sessionId=${sessionId} goal=${goal} bossRole_id=${bossRole_id} bossRole_title=${bossRole_title} bossRole_agent_type=${bossRole_agent_type} board_id=${board_id} todo_col=${todo_col} doing_col=${doing_col} done_col=${done_col} checkpointMin=${checkpointMin} memNs=${memNs} CTRL_URL=${CTRL_URL} MONO_DIR=${MONO_DIR} runFile=${runFile} REPO_ROOT=${REPO_ROOT}"
 ```
 
-**Emit `org:start` to dashboard:**
+After running the script above, read the `ORG_VARS:` line from its output and hold those values for Step 4 (embed them into the boss prompt as literals — **do not re-run bash to look them up**).
+
+---
+
+## Step 3 — Emit org:start (separate Bash call, re-derives from output)
+
+After the combined Step 2+3 script runs, emit `org:start` using the values printed by `ORG_VARS:`. Replace each `<X>` with the literal value from that line:
+
 ```bash
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -X POST "<CTRL_URL>/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
-    --arg session "$sessionId" \
-    --arg org "$orgName" \
-    --arg goal "$goal" \
-    --arg proj "$(pwd)" \
-    '{type:"org:start",session:$session,org:$org,goal:$goal,project:$proj,ts:(now*1000|floor)}')" || true
+    --arg session "<sessionId>" \
+    --arg org "<orgName>" \
+    --arg runId "<runId>" \
+    --arg goal "<goal>" \
+    --arg proj "<REPO_ROOT>" \
+    '{type:"org:start",session:$session,org:$org,runId:$runId,goal:$goal,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
 ---
 
 ## Step 4 — Spawn Boss Agent
 
-Using the variables derived in Step 2, spawn the boss agent via Task tool:
+Using the literal values from the `ORG_VARS:` output (not shell variables — they don't persist), spawn the boss agent via Task tool:
 
 ```javascript
 Task({
@@ -351,9 +354,9 @@ FULL COMMUNICATION TOPOLOGY:
 ${orgConfig.communication.map(e => `${e.from} → ${e.to} (${e.type})`).join('\n')}
 
 SHARED INFRASTRUCTURE:
-- Task board (monotask): board_id=${board_id}
-  Columns: Todo=${todo_col}  Doing=${doing_col}  Done=${done_col}
-- Memory namespace: ${memNs} (use: npx monomind@latest memory store/search --namespace ${memNs})
+- Task board (monotask): board_id=<board_id>
+  Columns: Todo=<todo_col>  Doing=<doing_col>  Done=<done_col>
+- Memory namespace: <memNs> (use: npx monomind@latest memory store/search --namespace <memNs>)
 - Dashboard events: POST to mastermind control server via curl — see CTRL_URL resolution in DASHBOARD EVENTS section below
 - Session ID for all events: ${sessionId}
 
@@ -429,52 +432,117 @@ APPROVAL GATE (when governance.policy is "board" or "strict"):
     sleep 30
   done
 
+DASHBOARD EVENT HELPER — resolve once at startup, reuse in every step:
+  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+  # Git-safe monomind dir — shared across all worktrees, survives branch switches:
+  GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || echo ".git")
+  # Resolve to absolute path (git returns relative ".git" for main checkout)
+  if [[ "$GIT_COMMON" != /* ]]; then GIT_COMMON="$REPO_ROOT/$GIT_COMMON"; fi
+  GIT_COMMON="${GIT_COMMON%/}"  # strip trailing slash if any
+  MONO_DIR="${GIT_COMMON}/monomind"
+  runFile="${MONO_DIR}/orgs/${orgName}/runs/${runId}.jsonl"
+
+⚠️  DASHBOARD EVENTS ARE MANDATORY — run every curl below exactly as written.
+    Do NOT skip, defer, or summarize. These keep the human-visible dashboard current.
+    Use Bash tool for all curl calls. Never use WebFetch (it doesn't support POST).
+    EVERY event MUST include runId:"${runId}" and org:"${orgName}" so the server routes it to the run file.
+
 STOP DETECTION (check this FIRST in every loop iteration):
   [ -f "${stopFile}" ] && echo STOP_REQUESTED
-If the file exists: emit org:complete event, clean up with "rm -f ${stopFile}", then exit.
+If the file exists: write run:complete to run file, emit org:complete via curl, then "rm -f ${stopFile}", then exit.
+  # REQUIRED — write run:complete directly to run file:
+  jq -cn --arg runId "${runId}" --arg org "${orgName}" \
+    '{type:"run:complete",runId:$runId,org:$org,status:"stopped",ts:(now*1000|floor)}' >> "${runFile}" || true
+  # REQUIRED — emit org:complete via curl (includes runId so it also gets appended):
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+    -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" --arg p "$REPO_ROOT" \
+      '{type:"org:complete",session:$s,org:$o,runId:$rid,project:$p,ts:(now*1000|floor)}')" || true
 
 OPERATING LOOP:
-1. Check for stop signal (see above). Exit if found.
-2. List unclaimed Todo cards: monotask card list ${board_id} --col ${todo_col} --json | jq '[.[] | select(.labels | index("claimed") | not)]'
-3. For each Todo card without a "claimed" label, assign to the appropriate role based on its "role:<id>" label. Skip cards whose prerequisites (monotask card prerequisite list) are not yet in the Done column.
-4. Spawn the assigned role agent via Task tool (run_in_background: true) with:
-   - Full role briefing (title, responsibilities, who they report to, memory namespace)
-   - The specific card title and card_id to work on
-   - Move the card to Doing before spawning: monotask card move ${board_id} $CARD_ID ${doing_col}
-   - Add label "claimed" to the card
-   - Report output via: npx monomind@latest memory store --key "${memNs}:report:<card_id>" --namespace "${memNs}"
-   - When complete, move card to Done: monotask card move ${board_id} $CARD_ID ${done_col}
-   - Emit org:agent:online event to dashboard before starting (use curl, see below)
+1. Check for stop signal (above). Exit with run:complete + org:complete events if found.
+
+2. List unclaimed Todo cards:
+   monotask card list ${board_id} --col ${todo_col} --json | jq '[.[] | select(.labels | index("claimed") | not)]'
+
+3. For each unclaimed Todo card, assign to the appropriate role based on its "role:<id>" label.
+   Skip cards whose prerequisites are not yet in the Done column.
+
+4. For EACH role agent you are about to spawn — do these steps in order:
+   a) Move card to Doing and mark claimed:
+      monotask card move ${board_id} $CARD_ID ${doing_col}
+      monotask card label add ${board_id} $CARD_ID "claimed"
+   b) REQUIRED — emit org:comms to dashboard (include runId):
+      curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+        -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" --arg p "$REPO_ROOT" \
+          --arg role "<role_id>" --arg task "<card title>" \
+          '{type:"org:comms",session:$s,org:$o,runId:$rid,from:"boss",to:$role,msg:("Assigning: "+$task),project:$p,ts:(now*1000|floor)}')" || true
+   c) REQUIRED — emit org:agent:online before spawning (include runId):
+      curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+        -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" --arg p "$REPO_ROOT" \
+          --arg role "<role_id>" --arg title "<role title>" --arg at "<agent_type>" \
+          '{type:"org:agent:online",session:$s,org:$o,runId:$rid,role:$role,title:$title,agent_type:$at,project:$p,ts:(now*1000|floor)}')" || true
+   d) Spawn the agent via Task tool (run_in_background: true) with:
+      - Full role briefing (title, responsibilities, who they report to, memory namespace)
+      - The specific card title and card_id to work on
+      - Report output via: npx monomind@latest memory store --key "${memNs}:report:<card_id>" --namespace "${memNs}"
+      - When complete, move card to Done: monotask card move ${board_id} $CARD_ID ${done_col}
+      - REQUIRED: Include the following DASHBOARD EVENTS block verbatim in every specialist prompt so
+        they can emit their own events to the dashboard:
+
+        DASHBOARD EVENTS — emit these at the start and end of your work (REQUIRED):
+          REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+          CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+          GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || echo ".git")
+          if [[ "$GIT_COMMON" != /* ]]; then GIT_COMMON="$REPO_ROOT/$GIT_COMMON"; fi
+          GIT_COMMON="${GIT_COMMON%/}"
+          MONO_DIR="${GIT_COMMON}/monomind"
+          runFile="${MONO_DIR}/orgs/${orgName}/runs/${runId}.jsonl"
+          # On start — announce you are working:
+          curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+            -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
+              --arg from "<role_id>" --arg msg "Starting: <card title>" \
+              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,ts:(now*1000|floor)}')" || true
+          # On completion — report back:
+          curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+            -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
+              --arg from "<role_id>" --arg msg "Completed: <one-sentence summary of output>" \
+              '{type:"org:comms",session:$s,org:$o,runId:$rid,from:$from,to:"boss",msg:$msg,ts:(now*1000|floor)}')" || true
+
+        Fill in the literal values for orgName="${orgName}", runId="${runId}", sessionId="${sessionId}" — embed them
+        directly in the prompt string so the specialist doesn't need to resolve them.
+
 5. Collect completed results from memory (search "${memNs}:report:")
-6. Synthesize reports, make decisions, create new cards in Todo column based on progress toward goal
-7. Write a run-completion entry to the activity log (used by the health dashboard for 7-day success rate):
-   activityFile=".monomind/orgs/${orgName}-activity.jsonl"
-   # Count Todo cards not yet claimed as the pending_tasks metric
+
+6. Synthesize reports, make decisions, create new cards in Todo column based on progress toward goal.
+   REQUIRED — after each decision, emit org:comms (include runId):
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+     -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" --arg p "$REPO_ROOT" \
+       --arg msg "<one-sentence summary of decision or finding>" \
+       '{type:"org:comms",session:$s,org:$o,runId:$rid,from:"boss",to:"all",msg:$msg,project:$p,ts:(now*1000|floor)}')" || true
+
+7. Write cycle-complete entry (directly to run file AND to activity log):
    pending_count=$(monotask card list ${board_id} --col ${todo_col} --json 2>/dev/null | jq '[.[] | select(.labels | index("claimed") | not)] | length' 2>/dev/null || echo 0)
-   echo "{\"type\":\"run:complete\",\"org\":\"${orgName}\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"pending\":${pending_count:-0}}" >> "$activityFile"
-   (On error/exception, write: {"type":"run:error","ts":"...", "org":"..."})
-8. Emit org:checkpoint event with progress summary
-9. Wait ${checkpointMin} minutes, then loop back to step 1
+   jq -cn --arg runId "${runId}" --arg org "${orgName}" --argjson pend "${pending_count:-0}" \
+     '{type:"run:cycle:complete",runId:$runId,org:$org,pending:$pend,ts:(now*1000|floor)}' >> "${runFile}" || true
+   activityFile=".monomind/orgs/${orgName}-activity.jsonl"
+   echo "{\"type\":\"run:cycle:complete\",\"org\":\"${orgName}\",\"runId\":\"${runId}\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"pending\":${pending_count:-0}}" >> "$activityFile" 2>/dev/null || true
+
+8. REQUIRED — emit org:checkpoint with a one-sentence progress summary (include runId):
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+     -d "$(jq -cn --arg s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" --arg p "$REPO_ROOT" \
+       --arg prog "<one sentence: what was done this cycle and what is next>" \
+       --argjson pend "${pending_count:-0}" \
+       '{type:"org:checkpoint",session:$s,org:$o,runId:$rid,progress:$prog,pending_tasks:$pend,project:$p,ts:(now*1000|floor)}')" || true
+
+9. Wait ${checkpointMin} minutes, then loop back to step 1.
 
 AGENT TYPES FOR YOUR TEAM:
 ${orgConfig.roles.filter(r => r.id !== bossRole.id).map(r =>
   `• ${r.title}: subagent_type="${r.agent_type}"`
 ).join('\n')}
 
-DASHBOARD EVENTS — emit via curl (NOT WebFetch — WebFetch does not support POST):
-  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-  curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
-    -H "Content-Type: application/json" \
-    -d "$(jq -cn --arg type TYPE --arg session SESSION --arg org ORG --arg proj "$REPO_ROOT" '{type:$type,session:$session,org:$org,project:$proj,ts:(now*1000|floor)}')"
-Payloads:
-- org:agent:online → add fields: role, title, agent_type
-- org:comms → add fields: from, to, msg
-- org:checkpoint → add fields: progress, pending_tasks
-- org:complete → no additional fields
-Note: always include project:$REPO_ROOT in all event payloads for correct multi-project SSE filtering
-
-START NOW: check for stop signal, assess the board, create initial tasks if none exist, then begin the operating loop.`
+START NOW: resolve CTRL_URL, check for stop signal, assess the board, create initial tasks if none exist, then begin the operating loop.`
 })
 ```
 
@@ -485,21 +553,20 @@ START NOW: check for stop signal, assess the board, create initial tasks if none
 Emit `org:agent:online` for the boss role (team member events are emitted by the boss itself):
 
 ```bash
-REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
 curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
     --arg session "$sessionId" \
     --arg org "$orgName" \
+    --arg runId "$runId" \
     --arg role "$bossRole_id" \
     --arg title "$bossRole_title" \
     --arg agent_type "$bossRole_agent_type" \
     --arg proj "$REPO_ROOT" \
-    '{type:"org:agent:online",session:$session,org:$org,role:$role,title:$title,agent_type:$agent_type,project:$proj,ts:(now*1000|floor)}')" || true
+    '{type:"org:agent:online",session:$session,org:$org,runId:$runId,role:$role,title:$title,agent_type:$agent_type,project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-(Use the scalar string variables `$bossRole_id`, `$bossRole_title`, `$bossRole_agent_type` derived by extracting fields from `bossRole` before constructing the curl call.)
+(Use the scalar string variables `$bossRole_id`, `$bossRole_title`, `$bossRole_agent_type` derived by extracting fields from `bossRole` before constructing the curl call. `CTRL_URL`, `MONO_DIR`, and `runId` were resolved in Step 3 — reuse those variables.)
 
 ---
 

package/.claude/skills/mastermind/sales.md

@@ -51,8 +51,8 @@ If this skill is invoked directly (not by master):
    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'"; exit 1; }
-   board_id=$(monotask board create "sales" --json 2>/dev/null | jq -r '.id // empty')
-   [ -z "$board_id" ] && echo "[sales] monotask board unavailable — board tracking skipped."
+   board_id=$(monotask board create "sales" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create sales 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')
@@ -120,7 +120,7 @@ Spawn one Task agent per workstream:
 - Account expansion: subagent_type "Account Strategist"
 - Competitive research: subagent_type "researcher"
 
-Tasks are saved to `docs/tasks/` by default. To execute: `/mastermind:do --file <TASK_FILE>`. With monotask: `/mastermind:do --monotask --space $SPACE_ID --board $TASK_BOARD_ID`.
+Also run /mastermind:do --board <board_id> to track execution.
 
 STEP 4 — COLLECT AND RETURN
 Collect all agent outputs. Return to caller: