@monoes/monomindcli 2.3.3 → 2.4.0

package/.claude/commands/mastermind/{approve.md → approvev1.md}

@@ -1,20 +1,23 @@
-<!-- Review and action pending approval requests from agents in a running org. -->
+<!-- LEGACY-ORG-V1 — Review and action pending approval requests from agents in a running v1 (prompt-orchestrated) org. Reach it only via /mastermind:approvev1. -->
+
+> **LEGACY-ORG-V1 (2026-07): v2 approvals arrive as question events in the dashboard Human Input tab — no command needed.**
+> This file-based approval queue applies only to v1 orgs not yet migrated off the `board_id`/`topology` config shape. Reach this legacy path only via `/mastermind:approvev1`.
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 
 ---
 
-**MASTERMIND: APPROVE**
+**MASTERMIND: APPROVE (v1, legacy)**
 
-Review and action pending approval requests from agents running inside an autonomous org. Agents request human approval before executing sensitive actions (publishing content, sending emails, making purchases, modifying infrastructure).
+Review and action pending approval requests from agents running inside a v1 (prompt-orchestrated) autonomous org. Agents request human approval before executing sensitive actions (publishing content, sending emails, making purchases, modifying infrastructure). v2 orgs surface approvals directly in the dashboard Human Input tab — no command needed.
 
 **Usage:**
 
 ```
-/mastermind:approve --org <name>                   List all pending approvals
-/mastermind:approve --org <name> --action approve --id <id>
-/mastermind:approve --org <name> --action reject  --id <id> --reason "Too risky"
-/mastermind:approve --org <name> --action inspect --id <id>
+/mastermind:approvev1 --org <name>                   List all pending approvals
+/mastermind:approvev1 --org <name> --action approve --id <id>
+/mastermind:approvev1 --org <name> --action reject  --id <id> --reason "Too risky"
+/mastermind:approvev1 --org <name> --action inspect --id <id>
 ```
 
 **Options:**
@@ -23,7 +26,7 @@ Review and action pending approval requests from agents running inside an autono
 `--id <approval_id>` — specific approval to approve/reject/inspect
 `--reason <text>` — reason for rejection (optional)
 
-No running orgs yet? Run `/mastermind:createorg` then `/mastermind:runorg`.
+No running orgs yet? Run `/mastermind:createorg` then `/mastermind:runorgv1` (v1 orgs only — v2 orgs use `/mastermind:runorg`).
 
 ---
 
@@ -74,7 +77,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{type:"session:start",session:$session,domain:"ops",prompt:("Approve requests for org: "+$org),mode:"confirm",project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-Invoke `Skill("mastermind-skills:approve")` passing: brain_context, org_name, action, approval_id, reason, caller: "command".
+Invoke `Skill("mastermind-skills:approvev1")` passing: brain_context, org_name, action, approval_id, reason, caller: "command".
 
 After skill returns: note the status. Emit `session:complete`:
 ```bash

package/.claude/commands/mastermind/help.md

@@ -18,6 +18,24 @@ Quick reference for all Mastermind skills and CLI commands available in this pro
 | `mastermind:swarm` | Swarm coordination reference — topologies, strategies, init patterns |
 | `mastermind:memory` | Memory CLI quick reference |
 
+## Org Runtime (v2 default)
+
+| Command | Description |
+|-------|-------------|
+| `/mastermind:createorg` | Define and save an org (always v2-shaped) |
+| `/mastermind:runorg` | Start a saved org via the Org Runtime v2 daemon (`monomind org run`/`serve`) — auto-migrates v1-shaped configs first |
+| `/mastermind:stoporg` | Stop a running scheduled org loop |
+| `/mastermind:orgstatus` | Detailed status for a single org |
+| `/mastermind:orgs` | List all saved orgs |
+
+### Legacy v1 (marker `LEGACY-ORG-V1` — reachable only under these explicit names)
+
+| Command | Description |
+|-------|-------------|
+| `/mastermind:runorgv1` | Legacy prompt-orchestrated org runner — superseded by `/mastermind:runorg` |
+| `/mastermind:approvev1` | Legacy approval queue for v1 orgs — v2 approvals arrive as dashboard question events instead |
+| `/mastermind:heartbeatv1` | Legacy manual agent wake-up for v1 orgs — v2 roles are live SDK sessions with no wake cycle |
+
 ## Core CLI Commands
 
 ```bash

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

@@ -118,7 +118,7 @@ digraph mastermind_routing {
 | Inspect or manage brain memory | `Skill("mastermind-skills:brain")` |
 | Technical portfolio, project state assessment | `Skill("mastermind-skills:techport")` |
 | Define/run an agent organization | `Skill("mastermind-skills:createorg")` / `Skill("mastermind-skills:runorg")` |
-| Review and action pending agent approval requests | `Skill("mastermind-skills:approve")` |
+| Review and action pending agent approval requests | `Skill("mastermind-skills:approvev1")` (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab) |
 | Autonomous build + review until clean | `Skill("mastermind-skills:autodev")` |
 | Isolate work in a git worktree | `Skill("mastermind-skills:worktree")` |
 | Write or improve a mastermind skill | `Skill("mastermind-skills:skill-builder")` |
@@ -253,8 +253,8 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 
 **Persistent agent orgs** — named teams that coordinate across sessions
 `/mastermind:createorg` — define an org: roles, hierarchy, goal
-`/mastermind:runorg` — start a saved org; boss agent assigns work to all roles
-`/mastermind:approve` — review and action pending approval requests from running org agents
+`/mastermind:runorg` — start a saved org via the Org Runtime v2 daemon (auto-migrates v1 configs); legacy prompt-orchestrated path: `/mastermind:runorgv1`
+`/mastermind:approvev1` — review and action pending approval requests from running org agents (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab)
 
 **Autonomous & advanced**
 `/mastermind:autodev` — research → build → review loop until clean (`--tillend` supported)

package/.claude/commands/mastermind/runorg.md

@@ -1,28 +1,14 @@
-<!-- Start a saved org as a persistent autonomous agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped. -->
+<!-- Start a saved org via the Org Runtime v2 daemon (monomind org run/serve). Validates the config, auto-migrates v1-shaped configs, starts the daemon, and confirms liveness. The legacy prompt-orchestrated path lives at /mastermind:runorgv1. -->
 
-> **DEPRECATED (2026-07): superseded by `monomind org run <name>` (SDK org runtime v2).**
-> This prompt-orchestrated path has no delivery guarantees and no ground-truth event stream.
-> It remains only for orgs not yet migrated. New orgs MUST use the daemon.
-
-**If $ARGUMENTS is empty:** List saved orgs and display the following.
+**If $ARGUMENTS is empty:** Output the following and wait.
 
 ---
 
 **MASTERMIND: RUN ORG**
 
-Running an org starts an autonomous agent organization. There are two modes:
-
-**Persistent org** (no schedule): a boss agent loads the org definition, assigns work to specialists from a shared board, and loops indefinitely. Stop with `/mastermind:stoporg --org <name>`.
-
-**Scheduled org** (created with `--schedule`): sets the org to `active` and runs the first iteration immediately. Subsequent iterations are self-scheduled via ScheduleWakeup. The loop stops cleanly within one interval after `/mastermind:stoporg --org <name>`.
-
-**Your saved orgs:**
-
-```bash
-npx -y monomind@latest org list 2>/dev/null \
-  || ls .monomind/orgs/*.json 2>/dev/null | grep -vE -- '-(state|goals|threads|activity|approvals|members|secrets|budgets|routines|issues|projects|workspaces|worktrees|environments|plugins|adapters|join-requests|bootstrap|project-workspaces|approval-comments|skills)\.json$' | xargs -I{} basename {} .json 2>/dev/null \
-  || echo "(none — run /mastermind:createorg to define one)"
-```
+Running an org starts it through the Org Runtime v2 daemon. Every role becomes
+a live SDK session; the daemon forwards dashboard events itself — no boss
+agent, no monotask board, no manual curl emissions.
 
 **Usage:**
 
@@ -30,130 +16,56 @@ npx -y monomind@latest org list 2>/dev/null \
 /mastermind:runorg --org <name>
 
 /mastermind:runorg --org content-team --task "Publish the Q2 product roundup post by Friday"
-
-/mastermind:runorg --org research-pod "Focus this week on competitor pricing changes"
 ```
 
 **Options:**
 `--org <name>` — which saved org to start (required; prompted if omitted)
 `--task <task>` — override the org's default goal for this run
-Any remaining text is passed as additional context to the boss agent.
 
 No orgs yet? Run `/mastermind:createorg` to define one.
 
----
+Your saved orgs:
 
-**If $ARGUMENTS is non-empty:** Execute the flow below.
+```bash
+npx -y monomind@latest org list 2>/dev/null || echo "(none — run /mastermind:createorg to define one)"
+```
 
 ---
 
-**STEP 0 — Extract loop-control flags (do this FIRST, before any other parsing)**
-
-Scan `$ARGUMENTS` for these flags and store their values. Remove them from the argument string before Step 1:
-
-| Flag | Variable | Default |
-|---|---|---|
-| `--rep <N>` | `current_rep = N` | absent |
-| `--loop <id>` | `LOOP_ID = id` | absent |
-| `--tillend` | `tillend_mode = true` | false |
-| `--maxruns <N>` | `tillend_maxruns = N` | 50 |
-| `--wait <N>` | `wait_seconds = N` | 60 |
-| `--repeat <N>` | `repeat_count = N` | 0 |
-
-⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind-skills:runorg") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind-skills:_repeat")` at the end.
+**If $ARGUMENTS is non-empty:** Execute the flow below.
 
 ---
 
-**STEP 1 — Parse org-specific flags**
-
-From the remaining `$ARGUMENTS` (after loop flags removed in Step 0):
+Parse `$ARGUMENTS` for:
 - `--org <name>` → org_name = <name>
-- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses org's stored goal)
-- Remaining text = additional context passed to the boss agent
+- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses the org's stored goal)
 
 If `--org` is not provided, list saved orgs and ask which to run:
 ```bash
-orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null)
-if [ -z "$orgs" ]; then
-  echo "No saved orgs found. Run /mastermind:createorg first."
-  exit 1
-fi
-echo "$orgs"
-```
-Ask: "Which org would you like to start? Available: <list from above>"
-
-Verify the org file exists before proceeding:
-```bash
-[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+npx -y monomind@latest org list 2>/dev/null || echo "(none — run /mastermind:createorg to define one)"
 ```
-If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
 
 Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
 
-Resolve session ID and project root:
+Generate a session ID:
 ```bash
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
 CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-# Reuse the loop's original sessionId for continuation runs (keeps all reps under one session)
-if [ -n "${LOOP_ID:-}" ] && [ -f ".monomind/loops/${LOOP_ID}.json" ]; then
-  session_id=$(jq -r '.sessionId // empty' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null)
-fi
-session_id="${session_id:-mm-$(date -u +%Y%m%dT%H%M%S)}"
 ```
 
-Emit `session:start` to dashboard:
-```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -H "Content-Type: application/json" \
-  -d "$(jq -cn \
-    --arg session "$session_id" \
-    --arg org "$org_name" \
-    --arg proj "$REPO_ROOT" \
-    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
-```
+Invoke `Skill("mastermind-skills:runorg")` passing: org_name: `$org_name`, task: task_override, session_id: `$session_id`, caller: "command".
 
-Emit `domain:dispatch`:
-```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -H "Content-Type: application/json" \
-  -d "$(jq -cn \
-    --arg session "$session_id" \
-    --arg org "$org_name" \
-    --arg proj "$REPO_ROOT" \
-    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
-```
-
-Invoke `Skill("mastermind-skills:runorg")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
-
-After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
+After skill returns: emit `session:complete`:
 ```bash
 curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
   -H "Content-Type: application/json" \
   -d "$(jq -cn \
     --arg session "$session_id" \
     --arg status "<status>" \
-    --arg proj "$REPO_ROOT" \
-    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],project:$proj,ts:(now*1000|floor)}')" || true
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],ts:(now*1000|floor)}')" || true
 ```
 
 Follow _protocol.md Brain Write Procedure for domain `ops`.
 
-
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
-
-After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
-```bash
-if [ -n "${LOOP_ID:-}" ]; then
-  LOOP_FILE=".monomind/loops/${LOOP_ID}.json"
-  if [ -f "$LOOP_FILE" ]; then
-    python3 -c "
-import json, sys
-f = sys.argv[1]; org = sys.argv[2]
-d = json.load(open(f))
-if 'orgName' not in d:
-    d['orgName'] = org
-    open(f, 'w').write(json.dumps(d, indent=2))
-" "$LOOP_FILE" "${org_name}" 2>/dev/null || true
-  fi
-fi
-```
+Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/runorgv1.md

@@ -0,0 +1,159 @@
+<!-- LEGACY-ORG-V1 — Start a saved org as a persistent, prompt-orchestrated agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped. Reach it only via /mastermind:runorgv1. -->
+
+> **LEGACY-ORG-V1 (2026-07): superseded by `monomind org run <name>` (SDK org runtime v2), delegated to by default via `/mastermind:runorg`.**
+> This prompt-orchestrated path has no delivery guarantees and no ground-truth event stream.
+> It remains only for orgs not yet migrated. New orgs MUST use the daemon. Reach this legacy path only via `/mastermind:runorgv1`.
+
+**If $ARGUMENTS is empty:** List saved orgs and display the following.
+
+---
+
+**MASTERMIND: RUN ORG**
+
+Running an org starts an autonomous agent organization. There are two modes:
+
+**Persistent org** (no schedule): a boss agent loads the org definition, assigns work to specialists from a shared board, and loops indefinitely. Stop with `/mastermind:stoporg --org <name>`.
+
+**Scheduled org** (created with `--schedule`): sets the org to `active` and runs the first iteration immediately. Subsequent iterations are self-scheduled via ScheduleWakeup. The loop stops cleanly within one interval after `/mastermind:stoporg --org <name>`.
+
+**Your saved orgs:**
+
+```bash
+npx -y monomind@latest org list 2>/dev/null \
+  || ls .monomind/orgs/*.json 2>/dev/null | grep -vE -- '-(state|goals|threads|activity|approvals|members|secrets|budgets|routines|issues|projects|workspaces|worktrees|environments|plugins|adapters|join-requests|bootstrap|project-workspaces|approval-comments|skills)\.json$' | xargs -I{} basename {} .json 2>/dev/null \
+  || echo "(none — run /mastermind:createorg to define one)"
+```
+
+**Usage:**
+
+```
+/mastermind:runorgv1 --org <name>
+
+/mastermind:runorgv1 --org content-team --task "Publish the Q2 product roundup post by Friday"
+
+/mastermind:runorgv1 --org research-pod "Focus this week on competitor pricing changes"
+```
+
+**Options:**
+`--org <name>` — which saved org to start (required; prompted if omitted)
+`--task <task>` — override the org's default goal for this run
+Any remaining text is passed as additional context to the boss agent.
+
+No orgs yet? Run `/mastermind:createorg` to define one.
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+**STEP 0 — Extract loop-control flags (do this FIRST, before any other parsing)**
+
+Scan `$ARGUMENTS` for these flags and store their values. Remove them from the argument string before Step 1:
+
+| Flag | Variable | Default |
+|---|---|---|
+| `--rep <N>` | `current_rep = N` | absent |
+| `--loop <id>` | `LOOP_ID = id` | absent |
+| `--tillend` | `tillend_mode = true` | false |
+| `--maxruns <N>` | `tillend_maxruns = N` | 50 |
+| `--wait <N>` | `wait_seconds = N` | 60 |
+| `--repeat <N>` | `repeat_count = N` | 0 |
+
+⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind-skills:runorgv1") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind-skills:_repeat")` at the end.
+
+---
+
+**STEP 1 — Parse org-specific flags**
+
+From the remaining `$ARGUMENTS` (after loop flags removed in Step 0):
+- `--org <name>` → org_name = <name>
+- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses org's stored goal)
+- Remaining text = additional context passed to the boss agent
+
+If `--org` is not provided, list saved orgs and ask which to run:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null)
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg first."
+  exit 1
+fi
+echo "$orgs"
+```
+Ask: "Which org would you like to start? Available: <list from above>"
+
+Verify the org file exists before proceeding:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+
+Resolve session ID and project root:
+```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")
+# Reuse the loop's original sessionId for continuation runs (keeps all reps under one session)
+if [ -n "${LOOP_ID:-}" ] && [ -f ".monomind/loops/${LOOP_ID}.json" ]; then
+  session_id=$(jq -r '.sessionId // empty' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null)
+fi
+session_id="${session_id:-mm-$(date -u +%Y%m%dT%H%M%S)}"
+```
+
+Emit `session:start` to dashboard:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Emit `domain:dispatch`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Invoke `Skill("mastermind-skills:runorgv1")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
+
+After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg status "<status>" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Follow _protocol.md Brain Write Procedure for domain `ops`.
+
+
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
+
+After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
+```bash
+if [ -n "${LOOP_ID:-}" ]; then
+  LOOP_FILE=".monomind/loops/${LOOP_ID}.json"
+  if [ -f "$LOOP_FILE" ]; then
+    python3 -c "
+import json, sys
+f = sys.argv[1]; org = sys.argv[2]
+d = json.load(open(f))
+if 'orgName' not in d:
+    d['orgName'] = org
+    open(f, 'w').write(json.dumps(d, indent=2))
+" "$LOOP_FILE" "${org_name}" 2>/dev/null || true
+  fi
+fi
+```

package/.claude/helpers/handlers/route-handler.cjs

@@ -326,8 +326,23 @@ module.exports = {
       // when the server is down or still warming.
       try {
         var sbPrompt = String(prompt || '');
-        // Skip slash commands and trivial prompts — injection would be noise.
-        if (sbPrompt.length >= 12 && sbPrompt.charAt(0) !== '/') {
+        // Skip slash commands and low-content prompts — injection would be
+        // noise. A prompt earns injection only when it carries at least two
+        // substantive terms ("what is next" / "ok go ahead" / "thanks" carry
+        // zero-to-one and must stay quiet; a real question about the project
+        // clears this easily).
+        var _SB_FILLER = new Set(['what', 'whats', 'is', 'are', 'was', 'were', 'the', 'this', 'that', 'these', 'those',
+          'next', 'now', 'then', 'and', 'but', 'for', 'not', 'you', 'your', 'can', 'could', 'should', 'would', 'will',
+          'lets', 'let', 'make', 'made', 'making', 'please', 'okay', 'yes', 'yeah', 'sure', 'thanks', 'thank',
+          'ahead', 'continue', 'proceed', 'more', 'again', 'how', 'why', 'when', 'where', 'who', 'which',
+          'with', 'about', 'from', 'into', 'onto', 'over', 'under', 'all', 'any', 'some', 'one', 'two', 'just',
+          'like', 'want', 'need', 'get', 'got', 'here', 'there', 'still', 'also', 'too', 'very', 'really',
+          'them', 'they', 'their', 'theirs', 'its', 'our', 'ours', 'him', 'her', 'his', 'hers',
+          'order', 'done', 'doing', 'did', 'does', 'goes', 'going', 'went', 'come', 'came', 'good', 'great', 'nice', 'fine']);
+        var _sbSubstantive = sbPrompt.toLowerCase().split(/[^a-z0-9]+/).filter(function(t) {
+          return t.length >= 3 && !_SB_FILLER.has(t);
+        });
+        if (_sbSubstantive.length >= 2 && sbPrompt.charAt(0) !== '/') {
           var sbKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
           if (fs.existsSync(path.join(sbKnowledgeDir, 'chunks.jsonl'))) {
             var sbHits = null;
@@ -353,7 +368,10 @@ module.exports = {
               if (sbResp.ok) {
                 var sbData = await sbResp.json();
                 if (sbData && Array.isArray(sbData.results) && sbData.results.length > 0) {
-                  sbHits = sbData.results.map(function(r) { return { key: r.key, value: r.content, score: r.score, metadata: {} }; });
+                  sbHits = sbData.results.map(function(r) {
+                    var src = (r.tags || []).find(function(t) { return t.indexOf('src:') === 0; });
+                    return { key: r.key, value: r.content, score: r.score, global: !!r.global, metadata: src ? { filePath: src.slice(4) } : {} };
+                  });
                   sbMethod = sbData.method === 'semantic' ? 'semantic' : 'keyword';
                 }
               }
@@ -366,13 +384,41 @@ module.exports = {
                 'second-brain-inject'
               );
             }
+            // Relevance floor: injecting weak matches pollutes every prompt's
+            // context — below 0.35 the excerpt is more likely noise than help.
+            if (sbHits) sbHits = sbHits.filter(function(h) { return (h.score || 0) >= 0.35; });
+
+            // Telemetry: append one JSONL line per evaluated prompt so the
+            // thresholds above can be tuned from real usage (and misses can
+            // seed the golden-set eval). Prompt text is NOT logged.
+            try {
+              var sbMetricsDir = path.join(CWD, '.monomind', 'metrics');
+              fs.mkdirSync(sbMetricsDir, { recursive: true });
+              var sbMetricsFile = path.join(sbMetricsDir, 'second-brain.jsonl');
+              try {
+                if (fs.existsSync(sbMetricsFile) && fs.statSync(sbMetricsFile).size > 512 * 1024) {
+                  var sbOld = fs.readFileSync(sbMetricsFile, 'utf-8').trim().split('\n');
+                  fs.writeFileSync(sbMetricsFile, sbOld.slice(-500).join('\n') + '\n', 'utf-8');
+                }
+              } catch (_) {}
+              fs.appendFileSync(sbMetricsFile, JSON.stringify({
+                ts: Date.now(),
+                method: sbMethod,
+                hits: sbHits ? sbHits.length : 0,
+                topScore: sbHits && sbHits[0] ? Number((sbHits[0].score || 0).toFixed(3)) : null,
+                promptLen: sbPrompt.length,
+                terms: _sbSubstantive.length,
+                injected: !!(sbHits && sbHits.length > 0),
+              }) + '\n', 'utf-8');
+            } catch (_) { /* telemetry never blocks */ }
+
             if (sbHits && sbHits.length > 0) {
               var sbLines = ['[SECOND_BRAIN] ' + sbHits.length + ' relevant excerpt(s) (' + sbMethod + ') from the project knowledge base:'];
               for (var sbI = 0; sbI < sbHits.length; sbI++) {
                 var sbH = sbHits[sbI];
                 var sbSrc = (sbH.metadata && sbH.metadata.filePath) ? String(sbH.metadata.filePath).split('/').slice(-2).join('/') : sbH.key;
                 var sbText = String(sbH.value || '').replace(/\s+/g, ' ').slice(0, 240);
-                sbLines.push('  • [' + sbSrc + '] ' + sbText);
+                sbLines.push('  • [' + sbSrc + (sbH.global ? ' · global' : '') + '] ' + sbText);
               }
               sbLines.push('  (deeper lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
               console.log(sbLines.join('\n'));

package/.claude/helpers/handlers/session-restore-handler.cjs

@@ -358,6 +358,17 @@ module.exports = {
         var _kbLastCheck = 0;
         try { _kbLastCheck = JSON.parse(fs.readFileSync(_kbMarkerPath, 'utf-8')).ts || 0; } catch (_) {}
         if (Date.now() - _kbLastCheck > 30 * 60 * 1000) {
+          // Marker BEFORE the scan (not only when dirty): the 2000-stat walk
+          // itself is what needs rate-limiting — on a clean tree it used to
+          // re-run on every single session start. Fail-closed: skip when the
+          // marker can't be written, so an unwritable disk can't cause
+          // per-session scans either.
+          var _kbMarkerOk = false;
+          try {
+            fs.writeFileSync(_kbMarkerPath, JSON.stringify({ ts: Date.now() }), 'utf-8');
+            _kbMarkerOk = true;
+          } catch (_) {}
+          if (!_kbMarkerOk) throw new Error('reindex marker unwritable — skipping scan');
           // Cheap bounded scan: any document changed since the last ingest?
           var _DOC_EXT = { '.md': 1, '.txt': 1, '.pdf': 1, '.docx': 1 };
           var _kbDirty = false;
@@ -380,24 +391,20 @@ module.exports = {
           };
           _kbWalk(CWD, 0);
           if (_kbDirty) {
-            var _kbMarkerOk = false;
-            try {
-              fs.writeFileSync(_kbMarkerPath, JSON.stringify({ ts: Date.now() }), 'utf-8');
-              _kbMarkerOk = true;
-            } catch (_) {}
-            if (_kbMarkerOk) {
-              var _kbSpawn = require('child_process').spawn;
-              var _kbChild = _kbSpawn('npx', ['-y', 'monomind@latest', 'doc', 'ingest', '.'], {
-                cwd: CWD,
-                detached: true,
-                stdio: 'ignore',
-                env: process.env,
-                shell: process.platform === 'win32',
-                windowsHide: true,
-              });
-              _kbChild.unref();
-              console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
-            }
+            var _kbSpawn = require('child_process').spawn;
+            var _kbChild = _kbSpawn('npx', ['-y', 'monomind@latest', 'doc', 'ingest', '.'], {
+              cwd: CWD,
+              detached: true,
+              stdio: 'ignore',
+              env: process.env,
+              shell: process.platform === 'win32',
+              windowsHide: true,
+            });
+            // Without an error listener, a missing npx binary emits an
+            // unhandled 'error' event and crashes the whole session-start hook.
+            _kbChild.on('error', function () { /* npx unavailable — reindex on a later session */ });
+            _kbChild.unref();
+            console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
           }
         }
       }

package/.claude/skills/mastermind-skills/agents.md

@@ -51,12 +51,15 @@ stateFile=".monomind/orgs/${org_name}-state.json"
 
 jq -r '(.roles // [])[] | "• [\(.id)] \(.title)  agent=\(.agent_type)  reports_to=\(.reports_to // "none")"' "$orgFile"
 
+# LEGACY-ORG-V1: the state file's per-agent heartbeat tracking is a v1 concept —
+# v2 orgs report live status via `monomind org status`/`org report` instead.
 # Overlay runtime status from state file if present
 if [ -f "$stateFile" ]; then
   echo ""
   echo "RUNTIME STATUS:"
   jq -r '.agents // {} | to_entries[] | "  \(.key): \(.value.status // "unknown")  last_beat=\(.value.last_heartbeat // "never")"' "$stateFile" 2>/dev/null || true
 fi
+# end LEGACY-ORG-V1
 ```
 
 Render as table:
@@ -134,6 +137,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
 
 ### pause / resume
 
+<!-- LEGACY-ORG-V1: the agent state/heartbeat file this pauses is a v1 concept. -->
 Update state file:
 
 ```bash
@@ -169,7 +173,7 @@ org: <org_name>
 agents_count: <N>
 ```
 
-Print summary and any suggested next actions (e.g. "Run /mastermind:heartbeat to trigger a manual heartbeat for this agent").
+Print summary and any suggested next actions (e.g. "Run /mastermind:heartbeatv1 to trigger a manual heartbeat for this agent").
 
 ---
 

package/.claude/skills/mastermind-skills/{approve.md → approvev1.md}

@@ -1,13 +1,16 @@
 ---
-name: mastermind-approve
-description: Mastermind approve — review and action pending approval requests from agents in a running org. Agents can request human approval before proceeding with sensitive actions.
+name: mastermind-approvev1
+description: "LEGACY-ORG-V1 (2026-07): v2 approvals arrive as question events in the dashboard Human Input tab — no skill needed. Mastermind approvev1 — review and action pending approval requests from agents in a running v1 (prompt-orchestrated) org. Agents can request human approval before proceeding with sensitive actions. Reach it only via `/mastermind:approvev1`."
 type: domain-skill
 default_mode: confirm
 ---
 
-# Mastermind Approve
+# Mastermind Approve (v1, legacy)
 
-This skill is invoked by `mastermind:approve` or directly via `/mastermind:approve`.
+> **LEGACY-ORG-V1 — file-based approval queue for prompt-orchestrated v1 orgs. Reach it only via `/mastermind:approvev1`.**
+> v2 approvals arrive as `question` events in the dashboard Human Input tab — there is no v2 approve skill, the dashboard UI is the approval surface. This skill remains only for orgs not yet migrated off the v1 `board_id`/`topology` config shape.
+
+This skill is invoked by `mastermind:approvev1` or directly via `/mastermind:approvev1`.
 
 ---
 
@@ -150,7 +153,7 @@ jq --arg id "$approval_id" \
 
 2. Emit `org:approval:requested` event to dashboard (so the human is notified).
 
-3. Poll for the approval decision — check the approvals file first (authoritative, updated by both the dashboard UI and `/mastermind:approve`), then fall back to memory:
+3. Poll for the approval decision — check the approvals file first (authoritative, updated by both the dashboard UI and `/mastermind:approvev1`), then fall back to memory:
 ```bash
 approvalsFile=".monomind/orgs/${orgName}-approvals.json"
 while true; do