monomind 2.3.2 → 2.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "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/_repeat.md

@@ -80,7 +80,7 @@ fi
   ```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 "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 "{\"type\":\"loop:hil:waiting\",\"loopId\":\"${LOOP_ID}\",\"hilFile\":\"${HIL_FILE}\",\"rep\":<current_rep>,\"ts\":$(date +%s)000}" || true
   ```
@@ -97,7 +97,7 @@ fi
   ```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 "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 "{\"type\":\"loop:hil:resolved\",\"loopId\":\"${LOOP_ID}\",\"rep\":<current_rep>,\"ts\":$(date +%s)000}" || true
   ```
@@ -185,7 +185,7 @@ If neither condition is true, skip to Section 4.
    CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
    # For tillend mode, repeat field is the safety cap
    REPEAT_VAL=$( [ "<tillend_mode>" = "true" ] && echo "<tillend_maxruns>(cap)" || echo "<repeat_count>" )
-   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+   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 "{\"type\":\"loop:start\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"$( [ '<tillend_mode>' = 'true' ] && echo 'tillend' || echo 'repeat' )\",\"repeat\":\"${REPEAT_VAL}\",\"wait\":<wait_seconds>,\"ts\":$(date +%s)000}" || true
    ```
@@ -274,7 +274,7 @@ RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloop
    ```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 "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 "{\"type\":\"loop:hil\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"hilFile\":\"${HIL_FILE}\",\"rep\":<current_rep>,\"files\":$(echo "$RECENT_HIL" | grep -v '^$' | jq -R . | jq -cs .),\"ts\":$(date +%s)000}" || true
    ```
@@ -300,7 +300,7 @@ RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloop
      ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"hilPending\":true,\"ts\":$(date +%s)000}" || true
      ```
@@ -364,7 +364,7 @@ Only if `GIT_CHANGES` was empty, answer these two questions about this run:
   ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"empty-round\",\"ts\":$(date +%s)000}" || true
   ```
@@ -381,7 +381,7 @@ Only if `GIT_CHANGES` was empty, answer these two questions about this run:
   ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"safety-cap\",\"ts\":$(date +%s)000}" || true
   ```
@@ -404,7 +404,7 @@ Only if `GIT_CHANGES` was empty, answer these two questions about this run:
   ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"ts\":$(date +%s)000}" || true
   ```
@@ -452,7 +452,7 @@ Emit `loop:tick`:
 ```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 "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 "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"${LOOP_TYPE}\",\"completedRep\":<current_rep>,\"nextRep\":<next_rep>,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true
 ```

package/packages/@monomind/cli/.claude/commands/mastermind/approve.md

@@ -65,7 +65,7 @@ CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control
 
 Emit `session:start`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \
@@ -78,7 +78,7 @@ Invoke `Skill("mastermind-skills:approve")` passing: brain_context, org_name, ac
 
 After skill returns: note the status. Emit `session:complete`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \

package/packages/@monomind/cli/.claude/commands/mastermind/architect.md

@@ -28,14 +28,14 @@ CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control
 
 Emit `session:start` before invoking the skill (use curl — WebFetch is blocked for localhost in Claude Code runtimes). Before executing the curl below, substitute the generated sessionId for `<sessionId>`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 '{"type":"session:start","session":"<sessionId>","domain":"architect","prompt":'"$(jq -Rn --arg p "$prompt" '$p')"',"ts":'"$(date +%s)"'000}' || true
 ```
 
 Emit `domain:dispatch` immediately after session:start. Before executing the curl below, substitute the generated sessionId for `<sessionId>`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 '{"type":"domain:dispatch","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
 ```
@@ -44,7 +44,7 @@ Invoke `Skill("mastermind-skills:architect")` passing: brain_context, prompt, pr
 
 After skill returns: note the status from the skill's output (`complete`, `partial`, or `blocked`). Emit `session:complete` using that status, then follow _protocol.md Brain Write Procedure for domain `architect`. Before executing the curl below, substitute the generated sessionId for `<sessionId>` and the skill's actual status for `<status>`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
 ```

package/packages/@monomind/cli/.claude/commands/mastermind/createorg.md

@@ -85,7 +85,7 @@ Stop after listing. Do not proceed to skill invocation.
    npx -y monomind@latest org delete "${delete_name}" --yes || {
      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")
-     result=$(curl -s -X DELETE "${CTRL_URL}/api/orgs/${delete_name}")
+     result=$(curl -s -X DELETE -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" "${CTRL_URL}/api/orgs/${delete_name}")
      echo "$result" | jq -r 'if .ok then "Org '\'''"${delete_name}"'''\'' deleted." else "Error: " + (.error // "unknown") end'
    }
    ```
@@ -106,7 +106,7 @@ CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control
 
 Emit `session:start` to dashboard:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \
@@ -118,7 +118,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 
 Emit `domain:dispatch`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \
@@ -129,7 +129,7 @@ Invoke `Skill("mastermind-skills:createorg")` passing: brain_context, prompt, or
 
 After skill returns: note the status (`complete`, `partial`, or `blocked`). Emit `session:complete`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \

package/packages/@monomind/cli/.claude/commands/mastermind/master.md

@@ -338,7 +338,7 @@ jq -n --arg sid "$SESSION_ID" --arg proj "$project_name" --arg prompt "$resolved
   && mv "$MONO_DIR/sessions/current.json.tmp" \
         "$MONO_DIR/sessions/current.json"
 CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -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 sid "$SESSION_ID" --arg prompt "$resolved_prompt" --arg mode "$mode" --arg proj "$REPO_ROOT" \
     '{type:"session:start",session:$sid,prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true
@@ -715,7 +715,7 @@ domains_needed=$(jq -r '.domains_needed[]? // empty' "$SESSION_STATE" | grep -v
 for domain in $domains_needed; do
   goal=$(jq -r --arg d "$domain" '.domain_goals[$d] // empty' "$SESSION_STATE")
   [ -z "$goal" ] && goal=$(jq -r '.prompt // ""' "$SESSION_STATE")
-  curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+  curl -s -o /dev/null -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 sid "$SESSION_ID" --arg d "$domain" --arg cmd "$goal" \
       '{type:"domain:dispatch",session:$sid,domain:$d,cmd:$cmd,ts:(now*1000|floor)}')" || true
@@ -889,7 +889,7 @@ echo "overall_status=$overall_status completed_domains=${completed_domains[*]}"
 
 completed_domains_json=$(jq -n '$ARGS.positional' --args "${completed_domains[@]}")
 
-curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -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 sid "$SESSION_ID" \

package/packages/@monomind/cli/.claude/commands/mastermind/repeat.md

@@ -101,7 +101,7 @@ EOF
 echo "LOOP_ID=${LOOP_ID}"
 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 "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 "{\"type\":\"loop:start\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/mastermind:repeat\",\"mode\":\"${LOOP_TYPE}\",\"maxReps\":${LOOP_MAXREPS},\"interval\":<INTERVAL>,\"ts\":$(date +%s)000}" || true
 ```
@@ -165,7 +165,7 @@ If `TILLEND_EMPTY=true`:
   rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
   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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"tillend\",\"ranReps\":<PREV_REP>,\"reason\":\"empty-round\",\"ts\":$(date +%s)000}" || true
   ```
@@ -178,7 +178,7 @@ If `--tillend` is active AND `CURRENT_REP > MAXRUNS` (safety cap reached):
   rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
   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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"tillend\",\"ranReps\":<PREV_REP>,\"reason\":\"safety-cap\",\"ts\":$(date +%s)000}" || true
   ```
@@ -193,7 +193,7 @@ Remove the state file and emit loop:complete:
 rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
 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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"ranReps\":<MAX_REPS>,\"ts\":$(date +%s)000}" || true
 ```
@@ -229,7 +229,7 @@ cat > ".monomind/loops/<LOOP_ID>.json" << EOF
 EOF
 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 "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 "{\"type\":\"loop:tick\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"${LOOP_TYPE}\",\"completedRep\":<PREV_REP>,\"nextRep\":<CURRENT_REP>,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true
 ```

package/packages/@monomind/cli/.claude/commands/mastermind/runorg.md

@@ -103,7 +103,7 @@ 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" \
+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" \
@@ -114,7 +114,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 
 Emit `domain:dispatch`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \
@@ -127,7 +127,7 @@ Invoke `Skill("mastermind-skills:runorg")` passing: brain_context, org_name: `$o
 
 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" \
+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" \

package/packages/@monomind/cli/.claude/commands/mastermind/stoporg.md

@@ -66,7 +66,7 @@ Invoke `Skill("mastermind-skills:stoporg")` passing: org_name: `$org_name`, sess
 
 After skill returns: emit `session:complete`:
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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" \

package/packages/@monomind/cli/.claude/helpers/control-start.cjs

@@ -172,11 +172,16 @@ async function main() {
     ? [...args, String(DEFAULT_PORT)]
     : [...args, 'ui', '--no-open', '--port', String(DEFAULT_PORT)];
 
+  // The child writes its ACTUAL bound port here — the only identity-proof
+  // signal. An HTTP probe alone can be answered by another project's server
+  // already holding the port (which then leaves control.json lying about
+  // where THIS project's events should go).
+  const BOUND_REPORT = path.join(CWD, '.monomind', `.bound-report-${Date.now()}.json`);
   const child = spawn(cmd, allArgs, {
     detached: true,
     stdio: 'ignore',
     cwd: CWD,
-    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD },
+    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD, MONOMIND_BOUND_REPORT: BOUND_REPORT },
   });
 
   child.unref();
@@ -189,11 +194,20 @@ async function main() {
   // If port 4242 was in use, server.mjs auto-increments (up to +10).
   // Poll a few ports to find where it actually bound and update control.json.
   const http = require('http');
+  // Resolves to the responder's pid (number), null for "answers but pid
+  // unreadable" (auth-walled or old server), or false for "no answer".
   function probePort(p) {
     return new Promise((resolve) => {
       const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
-        res.resume();
-        resolve(res.statusCode < 500);
+        let body = '';
+        res.on('data', (c) => { if (body.length < 4096) body += c; });
+        res.on('end', () => {
+          if (res.statusCode >= 500) return resolve(false);
+          try {
+            const pid = JSON.parse(body).pid;
+            resolve(typeof pid === 'number' ? pid : null);
+          } catch { resolve(null); }
+        });
       });
       req.on('error', () => resolve(false));
       req.on('timeout', () => { req.destroy(); resolve(false); });
@@ -201,20 +215,54 @@ async function main() {
   }
 
   // Give the server up to ~10 s to start, then confirm the actual port.
+  // Identity-first: the child's bound-report file (written by server.mjs) is
+  // authoritative; the HTTP probe only confirms a port when the responder's
+  // pid matches our child. A foreign server answering on DEFAULT_PORT must
+  // NOT be mistaken for ours — that lie misroutes every event emitter in
+  // this project (root cause of orgs running invisibly).
   async function confirmPort() {
+    let sawForeignOnDefault = false;
     for (let attempt = 0; attempt < 20; attempt++) {
       await new Promise(r => setTimeout(r, 500));
+      // 1) Authoritative: child self-reported its bound port
+      try {
+        const rep = JSON.parse(fs.readFileSync(BOUND_REPORT, 'utf8'));
+        if (rep && rep.pid === child.pid && typeof rep.port === 'number') {
+          try { fs.unlinkSync(BOUND_REPORT); } catch { /* ignore */ }
+          if (rep.port !== DEFAULT_PORT) {
+            writeStatus(child.pid, rep.port);
+            process.stdout.write(`[control] server bound to port ${rep.port} (updated control.json)\n`);
+          }
+          return;
+        }
+      } catch { /* not written yet or old server — fall through to probe */ }
+      // 2) Fallback: pid-matched HTTP probe (old servers without report support)
       for (let delta = 0; delta <= 10; delta++) {
         const p = DEFAULT_PORT + delta;
-        if (await probePort(p)) {
+        const responderPid = await probePort(p);
+        if (responderPid === false) continue;
+        if (responderPid === child.pid) {
           if (p !== DEFAULT_PORT) {
             writeStatus(child.pid, p);
             process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
           }
           return;
         }
+        if (p === DEFAULT_PORT && typeof responderPid === 'number') sawForeignOnDefault = true;
+        // pid mismatch or unreadable — not provably ours, keep scanning
       }
     }
+    try { fs.unlinkSync(BOUND_REPORT); } catch { /* ignore */ }
+    if (sawForeignOnDefault) {
+      // Another project's server owns DEFAULT_PORT and our child never proved
+      // its own port — point control.json at the live server instead of lying,
+      // and kill our redundant child.
+      try { process.kill(child.pid, 'SIGTERM'); } catch { /* already gone */ }
+      process.stdout.write(`[control] port ${DEFAULT_PORT} is served by another project's control server — reusing it (killed redundant child)\n`);
+      const foreignPid = await probePort(DEFAULT_PORT);
+      writeStatus(typeof foreignPid === 'number' ? foreignPid : 0, DEFAULT_PORT);
+      return;
+    }
     // Server never became reachable on any expected port — kill the child
     // rather than leave an orphan bound to some port nothing will ever read.
     // The next session-start simply retries.

package/packages/@monomind/cli/.claude/helpers/event-logger.cjs

@@ -66,12 +66,20 @@ function forwardToDashboard(entry) {
     const rawPort = Number(ctrl.port);
     const port = (Number.isInteger(rawPort) && rawPort >= 1024 && rawPort <= 65535) ? rawPort : 4242;
     const body = JSON.stringify({ ...entry, hookCaptured: true });
+    // Ingest is default-deny: attach the dashboard credential (written by
+    // server.mjs next to control.json) or the POST is silently rejected.
+    let authHdr = '';
+    try { authHdr = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf8').trim(); } catch {}
     const req = http.request({
       method: 'POST',
       hostname: 'localhost',
       port,
       path: '/api/mastermind/event',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        ...(authHdr ? { 'x-monomind-token': authHdr } : {}),
+      },
       timeout: 400,
     });
     req.on('error', () => {});

package/packages/@monomind/cli/.claude/helpers/handlers/capture-handler.cjs

@@ -201,12 +201,20 @@ function emitEvent(event) {
       }
       const u = new URL(baseUrl);
       const body = JSON.stringify(event);
+      // Ingest is default-deny: attach the dashboard credential (written by
+      // server.mjs next to control.json) or the POST is silently rejected.
+      let authHdr = '';
+      try { authHdr = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf8').trim(); } catch {}
       const req = http.request({
         hostname: u.hostname,
         port: parseInt(u.port || '4242', 10),
         path: '/api/mastermind/event',
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+          ...(authHdr ? { 'x-monomind-token': authHdr } : {}),
+        },
       }, () => {
         try { fs.unlinkSync(spoolFile); } catch {}
         resolve();

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -319,32 +319,62 @@ module.exports = {
       // ── Second Brain: per-request knowledge injection ──────────────────
       // When the project has an indexed knowledge base, surface the most
       // relevant excerpts for THIS prompt so Claude has them without having
-      // to decide to call knowledge_search. Keyword-scored over chunks.jsonl
-      // (a hook subprocess can't afford a 1-3s embedding-model load per
-      // prompt; full semantic search stays behind the knowledge_search MCP
-      // tool / `monomind doc search`).
-      // monolean: [keyword-only injection] — upgrade path: warm control-server
-      // endpoint holding the embedding model for semantic per-prompt retrieval.
+      // to decide to call knowledge_search. Semantic-first via the dashboard
+      // server's warm /api/knowledge/search (it holds the local embedding
+      // model hot — a hook subprocess can't afford a 1-3s model load per
+      // prompt); tokenized keyword scoring over chunks.jsonl as the fallback
+      // 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) !== '/') {
           var sbKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
           if (fs.existsSync(path.join(sbKnowledgeDir, 'chunks.jsonl'))) {
-            var sbSearch = hCtx._buildKnowledgeSearchFn(sbKnowledgeDir);
-            var sbHits = await hCtx.runWithTimeout(
-              function() { return sbSearch(sbPrompt, { namespace: 'knowledge:shared', limit: 3, minScore: 0.45 }); },
-              'second-brain-inject'
-            );
+            var sbHits = null;
+            var sbMethod = 'keyword';
+
+            // Semantic path: warm control-server endpoint (strictly local traffic;
+            // sbAuth is the local dashboard session value from .monomind, same one
+            // every other hook event POST attaches — not a checked-in secret).
+            try {
+              var sbCtrlUrl = 'http://localhost:4242';
+              try {
+                var sbCtl = JSON.parse(fs.readFileSync(path.join(CWD, '.monomind', 'control.json'), 'utf-8'));
+                if (sbCtl.url) sbCtrlUrl = sbCtl.url;
+              } catch (_) {}
+              var sbAuth = '';
+              try { sbAuth = fs.readFileSync(path.join(CWD, '.monomind', 'dashboard-token'), 'utf-8').trim(); } catch (_) {}
+              var sbResp = await fetch(sbCtrlUrl + '/api/knowledge/search', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-monomind-token': sbAuth },
+                body: JSON.stringify({ query: sbPrompt, namespace: 'knowledge:shared', limit: 3 }),
+                signal: AbortSignal.timeout(900),
+              });
+              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: {} }; });
+                  sbMethod = sbData.method === 'semantic' ? 'semantic' : 'keyword';
+                }
+              }
+            } catch (_) { /* server down or warming — fall back below */ }
+
+            if (!sbHits) {
+              var sbSearch = hCtx._buildKnowledgeSearchFn(sbKnowledgeDir);
+              sbHits = await hCtx.runWithTimeout(
+                function() { return sbSearch(sbPrompt, { namespace: 'knowledge:shared', limit: 3, minScore: 0.45 }); },
+                'second-brain-inject'
+              );
+            }
             if (sbHits && sbHits.length > 0) {
-              var sbLines = ['[SECOND_BRAIN] ' + sbHits.length + ' relevant excerpt(s) from the project knowledge base:'];
+              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('  (deeper/semantic lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
+              sbLines.push('  (deeper lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
               console.log(sbLines.join('\n'));
             }
           }

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_protocol.md

@@ -230,7 +230,7 @@ Resolve `CTRL_URL` at runtime: `jq -r '.url // "http://localhost:4242"' "$REPO_R
 ```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 -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -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 sid "$SESSION_ID" \

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_repeat.md

@@ -73,7 +73,7 @@ Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment
   ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"mode\":\"tillend\",\"ranReps\":<current_rep>,\"reason\":\"empty-round\",\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
   ```
@@ -103,7 +103,7 @@ If `current_rep >= repeat_count`:
   ```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 "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 "{\"type\":\"loop:complete\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"ranReps\":<repeat_count>,\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
   ```
@@ -151,7 +151,7 @@ Emit `loop:tick`:
 ```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 "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 "{\"type\":\"loop:tick\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/<command>\",\"completedRep\":<current_rep>,\"nextRep\":<next_rep>,\"nextAt\":${NEXT_AT},\"project\":\"${REPO_ROOT}\",\"ts\":$(date +%s)000}" || true
 ```

package/packages/@monomind/cli/.claude/skills/mastermind-skills/adapters.md

@@ -139,7 +139,7 @@ Emit `org:adapter:installed` event:
 ```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 "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 org "$org_name" --arg type "$adapter_type" --arg pkg "$package_name" \
     '{type:"org:adapter:installed",org:$org,adapter:$type,package:$pkg,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/agents.md

@@ -126,7 +126,7 @@ Then emit `org:agent:hired` event to dashboard:
 ```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 "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 org "$org_name" --arg role "$agent_id" --arg title "$title" \
     '{type:"org:agent:hired",org:$org,role:$role,title:$title,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/architect.md

@@ -67,7 +67,7 @@ If this skill is invoked directly (not by master):
    ```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 "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 '{"type":"session:start","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
    ```
@@ -104,7 +104,7 @@ If this skill is invoked directly (not by master):
    ```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 "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 '{"type":"session:complete","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
    ```
@@ -294,7 +294,7 @@ Then emit `agent:spawn` for the manager and spawn it. Before executing the curl
 ```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 "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 '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<manager_agent_type lowercased and hyphenated, e.g. software-architect>","task":"coordinate architecture analysis","ts":'"$(date +%s)"'000}'
 ```
@@ -444,7 +444,7 @@ BEFORE spawning each agent, emit agent:spawn to the live dashboard. Before each
 \`\`\`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 "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 '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<subagent_type lowercased and hyphenated, e.g. software-architect>","task":"<stream-description>","ts":'"$(date +%s)"'000}'
 \`\`\`
@@ -453,7 +453,7 @@ If handing off artifacts to another domain (e.g. build for refactoring implement
 \`\`\`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 "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 '{"type":"intercom","session":"<sessionId>","from":"architect","to":"<domain>","msg":"<msg>","ts":'"$(date +%s)"'000}'
 \`\`\`
@@ -464,7 +464,7 @@ BEFORE returning, emit domain:complete to the live dashboard:
 \`\`\`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 "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 '{"type":"domain:complete","session":"<sessionId>","domain":"architect","status":"<choose: complete | partial | blocked>","artifacts":[],"decisions":[],"ts":'"$(date +%s)"'000}'
 \`\`\`
@@ -552,7 +552,7 @@ Before executing the curl blocks below and when constructing the Task() descript
    ```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 "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 '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<resolved agent slug, e.g. software-architect>","task":"<prompt>","ts":'"$(date +%s)"'000}'
    ```
@@ -568,7 +568,7 @@ Before executing the curl blocks below and when constructing the Task() descript
    ```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 "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 '{"type":"domain:complete","session":"<sessionId>","domain":"architect","status":"complete","artifacts":[],"decisions":[],"ts":'"$(date +%s)"'000}'
    ```

package/packages/@monomind/cli/.claude/skills/mastermind-skills/backup.md

@@ -93,7 +93,7 @@ Emit `org:backup:created` event:
 ```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 "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 org "$org_name" --arg file "$archiveName" \
     '{type:"org:backup:created",org:$org,file:$file,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/bootstrap.md

@@ -151,7 +151,7 @@ Emit `org:bootstrap:complete` event:
 ```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 "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 org "$org_name" --arg boss "$boss_role_id" \
     '{type:"org:bootstrap:complete",org:$org,boss:$boss,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/costs.md

@@ -122,7 +122,7 @@ if [ "$budget" -gt 0 ] && [ -f "$stateFile" ]; then
     echo "ALERT: Org $org_name has used $(awk -v t=$total -v b=$budget 'BEGIN{printf "%.1f", t/b*100}')% of budget"
     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 "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 org "$org_name" --argjson total $total --argjson budget $budget \
         '{type:"org:budget:alert",org:$org,tokens_used:$total,budget:$budget,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/heartbeat.md

@@ -71,7 +71,7 @@ jq --arg id "$agent_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" --arg source "
 
 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 "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 org "$org_name" \
@@ -123,7 +123,7 @@ HEARTBEAT PROCEDURE:
 
 4. Report completion — emit heartbeat:complete event:
    CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-   curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+   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 org "${org_name}" --arg role "${agent_id}" --arg title "${agentTitle}" \
        '{type:"org:heartbeat:complete",org:$org,role:$role,title:$title,ts:(now*1000|floor)}')" || true
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/idea.md

@@ -1089,7 +1089,7 @@ if [ -n "$SESSION_ID" ]; then
     --argjson next_actions '["<next_action_1>","<next_action_2>"]' \
     '{domain:$domain,status:$status,artifacts:$artifacts,next_actions:$next_actions}' \
     > "$MONO_DIR/sessions/${SESSION_ID}/idea.json"
-  curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+  curl -s -o /dev/null -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 sid "$SESSION_ID" --arg status "<status>" \
       '{type:"domain:complete",session:$sid,domain:"idea",status:$status,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/monitor.md

@@ -384,7 +384,7 @@ jq --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '.last_tick = $ts' "$cfg" > "$tmp"
 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")
 SESSION_ID="monitor-${name}-$(date -u +%Y%m%dT%H%M%S)"
-curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -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 sid "$SESSION_ID" --arg name "$name" \
     '{type:"monitor:tick",session:$sid,monitor:$name,ts:(now*1000|floor)}')" || true
@@ -959,7 +959,7 @@ jq '.stats.done += 1' "$cfg" > "$tmp" && mv "$tmp" "$cfg"
 
 **Emit dashboard event:**
 ```bash
-curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
+curl -s -o /dev/null -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 sid "$SESSION_ID" --arg name "$name" --arg title "$task_title" \
     '{type:"monitor:task:done",session:$sid,monitor:$name,task:$title,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/org-settings.md

@@ -161,7 +161,7 @@ Emit `org:settings:updated` event:
 ```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 "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 org "$org_name" --arg field "$field" --arg value "$value" \
     '{type:"org:settings:updated",org:$org,field:$field,value:$value,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/plugins.md

@@ -130,7 +130,7 @@ Emit `org:plugin:installed` event:
 ```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 "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 org "${org_name:-global}" --arg id "$pluginId" --arg pkg "$package_name" \
     '{type:"org:plugin:installed",org:$org,plugin:$id,package:$pkg,ts:(now*1000|floor)}')" || true

package/packages/@monomind/cli/.claude/skills/mastermind-skills/runorg.md

@@ -117,7 +117,7 @@ CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control
 ### 1.6.3 — Emit org:start event
 
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 "$sessionId" \
@@ -161,7 +161,7 @@ If `LOOP_STATUS == "active"` or `LOOP_STATUS == "paused"`:
 
 2. Emit `org:stop` to signal this iteration is pausing:
    ```bash
-   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+   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 org "$orgName" \
@@ -182,7 +182,7 @@ If `LOOP_STATUS == "active"` or `LOOP_STATUS == "paused"`:
      || python3 -c "import datetime; print(datetime.datetime.utcfromtimestamp($next_ts).strftime('%Y-%m-%dT%H:%M:%SZ'))")
    tmp="${orgFile}.tmp"
    jq --arg next "$next_iso" '.loop.next_run = $next' "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
-   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+   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 org "$orgName" --arg next "$next_iso" --arg proj "$REPO_ROOT" \
        '{type:"org:loop:scheduled",org:$org,next_run:$next,project:$proj,ts:(now*1000|floor)}')" || true
@@ -312,10 +312,12 @@ fi
 # 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")
+GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || true)
+# Non-git project: never fabricate a .git/ dir — fall back to .monomind
+[ -z "$GIT_COMMON" ] && GIT_COMMON="__NOGIT__"
 if [[ "$GIT_COMMON" != /* ]]; then GIT_COMMON="$REPO_ROOT/$GIT_COMMON"; fi
 GIT_COMMON="${GIT_COMMON%/}"
-MONO_DIR="${GIT_COMMON}/monomind"
+if [ "$GIT_COMMON" = "__NOGIT__" ] || [ "${GIT_COMMON#*__NOGIT__}" != "$GIT_COMMON" ]; then MONO_DIR="$REPO_ROOT/.monomind"; else MONO_DIR="${GIT_COMMON}/monomind"; fi
 
 # Create run file and write run:start
 runDir="${MONO_DIR}/orgs/${orgName}/runs"
@@ -329,7 +331,7 @@ jq -cn \
 
 # Emit session:start first — creates the chat tab session record and writes active-session.json
 # so capture-handler can tag all subsequent agent:spawn / agent:complete events with this session
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 "$sessionId" \
@@ -338,7 +340,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
     '{type:"session:start",session:$session,org:$org,prompt:$prompt,ts:(now*1000|floor)}')" || true
 
 # Emit org:start — must run here while CTRL_URL/runId/orgName are in scope
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 "$sessionId" \
@@ -457,7 +459,7 @@ APPROVAL GATE (when governance.policy is "board" or "strict"):
      '.approvals += [{"id":$id,"agent_id":$agent,"title":$title,"action":$action,"risk_level":$risk,"status":"pending","requested_at":(now|todate)}]' \
      "$approvalsFile" > "${approvalsFile}.tmp" && mv "${approvalsFile}.tmp" "$approvalsFile"
   # Emit approval request event so human sees it in dashboard
-  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+  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 org "${orgName}" --arg id "$approval_id" --arg title "<title>" \
       '{type:"org:approval:requested",org:$org,approval_id:$id,title:$title,ts:(now*1000|floor)}')" || true
   # Poll until approved or rejected (max 30 min).
@@ -478,11 +480,13 @@ 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")
+  GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || true)
+# Non-git project: never fabricate a .git/ dir — fall back to .monomind
+[ -z "$GIT_COMMON" ] && GIT_COMMON="__NOGIT__"
   # 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"
+  if [ "$GIT_COMMON" = "__NOGIT__" ] || [ "${GIT_COMMON#*__NOGIT__}" != "$GIT_COMMON" ]; then MONO_DIR="$REPO_ROOT/.monomind"; else MONO_DIR="${GIT_COMMON}/monomind"; fi
   runFile="${MONO_DIR}/orgs/${orgName}/runs/${runId}.jsonl"
 
 ⚠️  DASHBOARD EVENTS ARE MANDATORY — run every curl below exactly as written.
@@ -497,7 +501,7 @@ If the file exists: write run:complete to run file, emit org:complete via curl,
   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" \
+  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 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
 
@@ -511,7 +515,7 @@ OPERATING LOOP:
      if [ "$(echo "$_pending" | jq 'length')" -gt 0 ]; then
        echo "$_pending" | jq -r '.[] | .text // .msg // ""'
        jq '[.[] | if .status == "pending" then .status = "processed" else . end]' "$_threads" > "${_threads}.tmp" && mv "${_threads}.tmp" "$_threads" || true
-       curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+       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 s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
            --arg msg "Received user message — adjusting plan if needed" \
            '{type:"org:comms",session:$s,org:$o,runId:$rid,from:"boss",to:"user",msg:$msg,ts:(now*1000|floor)}')" || true
@@ -529,12 +533,12 @@ OPERATING LOOP:
       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" \
+      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 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" \
+      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 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
@@ -549,23 +553,25 @@ OPERATING LOOP:
         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")
+          GIT_COMMON=$(git rev-parse --git-common-dir 2>/dev/null || true)
+# Non-git project: never fabricate a .git/ dir — fall back to .monomind
+[ -z "$GIT_COMMON" ] && GIT_COMMON="__NOGIT__"
           if [[ "$GIT_COMMON" != /* ]]; then GIT_COMMON="$REPO_ROOT/$GIT_COMMON"; fi
           GIT_COMMON="${GIT_COMMON%/}"
-          MONO_DIR="${GIT_COMMON}/monomind"
+          if [ "$GIT_COMMON" = "__NOGIT__" ] || [ "${GIT_COMMON#*__NOGIT__}" != "$GIT_COMMON" ]; then MONO_DIR="$REPO_ROOT/.monomind"; else MONO_DIR="${GIT_COMMON}/monomind"; fi
           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" \
+          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 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" \
+          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 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
           # When your task is fully complete — signal offline:
-          curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \
+          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 s "${sessionId}" --arg o "${orgName}" --arg rid "${runId}" \
               --arg from "<role_id>" \
               '{type:"org:agent:offline",session:$s,org:$o,runId:$rid,from:$from,ts:(now*1000|floor)}')" || true
@@ -588,7 +594,7 @@ OPERATING LOOP:
 
 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" \
+   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 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
@@ -601,7 +607,7 @@ OPERATING LOOP:
    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" \
+   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 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}" \
@@ -705,7 +711,7 @@ If `caller` is not "command", follow _protocol.md Brain Write Procedure for doma
 When you create or modify a file that represents output of this org run, emit:
 
 ```bash
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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 s "${sessionId}" \

package/packages/@monomind/cli/.claude/skills/mastermind-skills/stoporg.md

@@ -52,7 +52,7 @@ CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control
 npx -y monomind@latest org stop "${org_name}" \
   || { mkdir -p ".monomind/orgs/${org_name}"; date -u +%Y-%m-%dT%H:%M:%SZ > ".monomind/orgs/${org_name}/stop"; }
 # Also POST to the control server in case a dashboard-started instance is running
-curl -s -X POST "${CTRL_URL}/api/orgs/${org_name}/stop" >/dev/null 2>&1 || true
+curl -s -X POST -H "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" "${CTRL_URL}/api/orgs/${org_name}/stop" >/dev/null 2>&1 || true
 echo "Stop requested for org '${org_name}' (v2 daemon exits within 2s)."
 ```
 - Exit.
@@ -92,7 +92,7 @@ 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")
 
 # org:stop — signals dashboard to update status to stopped
-curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+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:-manual}" \

package/packages/@monomind/cli/dist/src/ui/server.mjs

@@ -1013,6 +1013,31 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
   // (not per-request inside the request handler below) since both only
   // close over per-server-start state (dashboardAuthValue) plus their
   // explicit req/res/corsOrigin params. ──────────────────────────────────
+  // ── Second Brain warm bridge: lazy singleton import of the compiled memory
+  // bridge (loads the local embedding model once for the server's lifetime).
+  // Boot-warmed below only when this project actually has a knowledge base.
+  let _knowledgeBridgePromise = null;
+  const _getKnowledgeBridge = () => {
+    if (!_knowledgeBridgePromise) {
+      _knowledgeBridgePromise = import('../memory/memory-bridge.js').catch((err) => {
+        _knowledgeBridgePromise = null; // allow retry on next request
+        if (process.env.MONOMIND_DEBUG) console.error('[knowledge] bridge import failed:', err.message);
+        return null;
+      });
+    }
+    return _knowledgeBridgePromise;
+  };
+  try {
+    if (fs.existsSync(path.join(projectDir || process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl'))) {
+      // Warm off the startup path: first hook request should hit a hot model.
+      const _warmTimer = setTimeout(() => {
+        _getKnowledgeBridge().then(b => b?.bridgeSearchEntries?.({ query: 'warmup', namespace: 'knowledge:shared', limit: 1 }))
+          .catch(() => { /* warm-up is best-effort */ });
+      }, 3000);
+      if (_warmTimer.unref) _warmTimer.unref();
+    }
+  } catch (_) { /* non-fatal */ }
+
   const _checkAuth = (req) => {
     let _suppliedAuth = req.headers['x-monomind-token'] || '';
     if (!_suppliedAuth) {
@@ -5888,6 +5913,46 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
+    // POST /api/knowledge/search — warm semantic knowledge search for hooks.
+    // The dashboard server is the one long-lived process on the machine, so it
+    // holds the local embedding model warm; per-prompt hook subprocesses (which
+    // cannot afford a model load) POST here and fall back to keyword scoring
+    // when this endpoint is cold/absent. Fully local — model + store on disk.
+    if (req.method === 'POST' && url === '/api/knowledge/search') {
+      let body = '';
+      req.on('data', c => { body += c; });
+      req.on('end', async () => {
+        try {
+          const payload = JSON.parse(body || '{}');
+          const query = String(payload.query || '').slice(0, 2000);
+          const limit = Math.min(Math.max(parseInt(payload.limit, 10) || 3, 1), 10);
+          const namespace = typeof payload.namespace === 'string' && /^[A-Za-z0-9:_-]{1,128}$/.test(payload.namespace)
+            ? payload.namespace : 'knowledge:shared';
+          if (!query) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end('{"error":"query required"}');
+            return;
+          }
+          const bridge = await _getKnowledgeBridge();
+          if (!bridge) {
+            res.writeHead(503, { 'Content-Type': 'application/json' });
+            res.end('{"error":"knowledge bridge unavailable"}');
+            return;
+          }
+          const out = await bridge.bridgeSearchEntries({ query, namespace, limit });
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({
+            method: out?.searchMethod || 'none',
+            results: (out?.results || []).map(r => ({ key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score })),
+          }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
     // GET /api/mastermind/metrics — aggregate system metrics from token-summary and swarm-activity
     if (req.method === 'GET' && url === '/api/mastermind/metrics') {
       try {
@@ -6260,6 +6325,16 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
   const boundPort = await bindServer(server, port);
   const url = `http://localhost:${boundPort}`;
 
+  // Self-report the ACTUAL bound port for the spawner (control-start.cjs).
+  // An HTTP probe cannot distinguish this server from another project's server
+  // already answering on the requested port — this file is identity-proof.
+  if (process.env.MONOMIND_BOUND_REPORT) {
+    try {
+      fs.mkdirSync(path.dirname(process.env.MONOMIND_BOUND_REPORT), { recursive: true });
+      fs.writeFileSync(process.env.MONOMIND_BOUND_REPORT, JSON.stringify({ pid: process.pid, port: boundPort, ts: Date.now() }));
+    } catch (_) { /* non-fatal — spawner falls back to pid-matched HTTP probe */ }
+  }
+
   // ── One-time migration: mastermind-sessions.json → per-session JSONL ─────
   // Runs once on startup. Existing sessions in the old monolithic format are
   // split into individual JSONL files + _index.json for O(1) event writes.

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "type": "module",
   "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",