monomind 2.3.3 → 2.3.4

package/README.md

@@ -102,11 +102,25 @@ monomind org run content-team --task "Build and publish 3 blog posts per week"
 #   assigns work to role agents, coordinates until the task completes
 #   or you stop it. Every event streams into the dashboard above.
 
-monomind org status content-team    # runtime state
+monomind org status content-team    # runtime state (detects crashed daemons)
 monomind org stop content-team      # request a graceful stop
-monomind org list                   # every org + status
+monomind org list                   # every org + roles, schedule, status
 ```
 
+### Observe, steer, and let it learn
+
+```bash
+monomind org logs content-team --follow      # live event stream in the terminal
+monomind org report content-team             # outcome, per-role tokens vs budget, assets
+monomind org questions content-team          # what agents asked via ask_human
+monomind org answer content-team q-123 "yes" # answer live or queued — no dashboard needed
+monomind org create blog --template content-team --goal "3 posts/week"   # scaffold from a template
+monomind org validate blog                   # schema + structural checks before running
+monomind org run blog --dry-run              # preview each role's exact briefing
+```
+
+Orgs are self-improving: the coordinator records every run's outcome (`org_complete`), the next run is briefed on it, and all agents can query accumulated cross-run memory with `org_recall` — a scheduled org gets smarter every cycle instead of starting cold. Crashed agent sessions restart automatically with backoff.
+
 ### What runs under the hood
 
 | What | How |
@@ -196,9 +210,28 @@ monomind org run my-team          # run your first AI org (see .monomind/orgs/sa
 
 ---
 
+## 📚 Second Brain — Your Documents, Retrieved by Meaning
+
+Drop documents (Markdown, TXT, PDF, DOCX) anywhere in your project and run `monomind init` — the Second Brain activates itself. No flags, no configuration, no accounts. Everything runs on your machine: a local embedding model (MiniLM via transformers.js) and a local SQLite vector store. **Your notes never leave your computer.**
+
+From then on, every substantive prompt you type in Claude Code is automatically answered *with your own knowledge in context* — a hook retrieves the most relevant excerpts semantically (the always-on dashboard keeps the model warm, ~60ms per lookup) and injects them before Claude starts thinking. Ask "when do new parents get time off" and the parental-leave section of your handbook is already on the table, even though you never used the word "leave".
+
+```bash
+monomind doc ingest ./notes        # index documents (init + session-start do this automatically)
+monomind doc search -q "pricing psychology in checkout"   # semantic search, by meaning not keywords
+monomind doc list                  # what's indexed
+monomind doc export                # portable OKF bundle — move your brain between machines
+```
+
+Retrieval quality is a tested invariant, not a hope: a golden-set eval (paraphrase queries against notes written in different vocabulary) runs in CI with an 80% recall bar.
+
+> **Privacy note:** the embedding model (~90MB) is fetched once from HuggingFace's CDN when your first document is indexed, then cached locally forever. That download is the only outbound request the Second Brain ever makes — your documents and queries never leave your machine. Offline at first index? Search degrades gracefully to keyword matching and `monomind doctor` tells you how to warm up later.
+
+---
+
 ## 🧠 Memory That Persists
 
-Every session, every agent, every org writes to a persistent memory store — a JSON pattern store with episodic recall that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
+Every session, every agent, every org writes to a persistent memory store that survives across sessions — text plus embedding vectors in local SQLite (better-sqlite3, pure-WASM fallback), embedded by a local model. No cloud vector database, no API keys, no data transmission. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
 
 ```mermaid
 graph TD
@@ -217,7 +250,7 @@ graph TD
 
 ```bash
 monomind memory store "key insight" --namespace my-project
-monomind memory search "auth implementation"     # BM25 + semantic hybrid
+monomind memory search "auth implementation"     # semantic (local embeddings) with keyword fallback
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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;
@@ -366,6 +381,34 @@ 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++) {

package/packages/@monomind/cli/.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');
           }
         }
       }