monomind 2.3.1 → 2.3.3

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/commands/cleanup.d.ts

@@ -11,6 +11,20 @@ interface StaleScratchItem {
     description: string;
     size: number;
 }
+/**
+ * Find prunable entries under the per-project data base (default
+ * ~/.monomind/projects). Exported for tests — `baseDir`/`now` injectable.
+ *
+ * Classification per dir:
+ * - `origin.json` present and its recorded path still exists → keep the dir,
+ *   but flag a leftover `lancedb/` subdir (dead since the SQLite engine swap).
+ * - `origin.json` present, recorded path gone → orphaned → prune.
+ * - no `origin.json` (pre-2.3.1 dirs can't prove their origin) → prune only
+ *   when untouched for {@link UNKNOWN_DIR_MAX_AGE_MS} — or immediately with
+ *   `--aggressive`, which treats unprovable dirs as junk (safe: every live
+ *   project rewrites origin.json on its next memory access).
+ */
+export declare function findOrphanedProjectData(baseDir: string, now: number, aggressive: boolean): StaleScratchItem[];
 /**
  * Find stale mastermind scratch under `.monomind/taskdev/` and `.monomind/loops/`.
  * Exported for tests. Never returns `progress.md` (the taskdev recovery ledger),

package/packages/@monomind/cli/dist/src/commands/cleanup.js

@@ -33,6 +33,63 @@ const KEEP_CONFIG_PATHS = [
 // monolean: manual flag only — upgrade path: invoke from the `cache` background worker so crashed-run scratch is pruned without anyone remembering the flag
 const SCRATCH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // taskdev scratch older than this is stale
 const LOOP_STALE_GRACE_MS = 24 * 60 * 60 * 1000; // a live loop reschedules every <=1h; overdue by a day = abandoned
+/** Orphaned per-project data (--data): ~/.monomind/projects/<slug> dirs whose
+ * source project is gone, plus dead lancedb/ dirs left by the pre-2.3.1 engine. */
+const UNKNOWN_DIR_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Find prunable entries under the per-project data base (default
+ * ~/.monomind/projects). Exported for tests — `baseDir`/`now` injectable.
+ *
+ * Classification per dir:
+ * - `origin.json` present and its recorded path still exists → keep the dir,
+ *   but flag a leftover `lancedb/` subdir (dead since the SQLite engine swap).
+ * - `origin.json` present, recorded path gone → orphaned → prune.
+ * - no `origin.json` (pre-2.3.1 dirs can't prove their origin) → prune only
+ *   when untouched for {@link UNKNOWN_DIR_MAX_AGE_MS} — or immediately with
+ *   `--aggressive`, which treats unprovable dirs as junk (safe: every live
+ *   project rewrites origin.json on its next memory access).
+ */
+export function findOrphanedProjectData(baseDir, now, aggressive) {
+    const out = [];
+    if (!existsSync(baseDir))
+        return out;
+    for (const name of readdirSync(baseDir)) {
+        if (name.startsWith('.'))
+            continue;
+        const dir = join(baseDir, name);
+        let mtime = 0;
+        try {
+            const st = lstatSync(dir);
+            if (!st.isDirectory())
+                continue;
+            mtime = st.mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const originFile = join(dir, 'origin.json');
+        let originPath = null;
+        let hasOrigin = false;
+        try {
+            originPath = String(JSON.parse(readFileSync(originFile, 'utf-8')).path ?? '');
+            hasOrigin = originPath.length > 0;
+        }
+        catch { /* no/corrupt marker */ }
+        if (hasOrigin && originPath && existsSync(originPath)) {
+            const lance = join(dir, 'lancedb');
+            if (existsSync(lance))
+                out.push({ path: lance, description: `dead lancedb store (project: ${originPath})`, size: 0 });
+            continue;
+        }
+        if (hasOrigin) {
+            out.push({ path: dir, description: `orphaned project data (origin gone: ${originPath})`, size: 0 });
+        }
+        else if (aggressive || now - mtime > UNKNOWN_DIR_MAX_AGE_MS) {
+            out.push({ path: dir, description: aggressive ? 'unverifiable project data (no origin marker)' : 'unverifiable project data (untouched >30d)', size: 0 });
+        }
+    }
+    return out;
+}
 /**
  * Find stale mastermind scratch under `.monomind/taskdev/` and `.monomind/loops/`.
  * Exported for tests. Never returns `progress.md` (the taskdev recovery ledger),
@@ -208,6 +265,19 @@ export const cleanupCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'data',
+            short: 'd',
+            description: 'Prune orphaned per-project data in ~/.monomind/projects (gone projects, dead lancedb stores)',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'aggressive',
+            description: 'With --data: also prune dirs that cannot prove their origin (pre-2.3.1, no origin marker)',
+            type: 'boolean',
+            default: false,
+        },
     ],
     examples: [
         {
@@ -232,6 +302,35 @@ export const cleanupCommand = {
         const keepConfig = ctx.flags['keep-config'] === true;
         const cwd = ctx.cwd;
         const dryRun = !force;
+        if (ctx.flags.data === true) {
+            const { homedir } = await import('os');
+            const baseDir = join(homedir(), '.monomind', 'projects');
+            output.writeln();
+            output.writeln(output.bold(dryRun ? 'Monomind Project-Data Cleanup (dry run)' : 'Monomind Project-Data Cleanup'));
+            output.writeln();
+            const orphans = findOrphanedProjectData(baseDir, Date.now(), ctx.flags.aggressive === true);
+            if (orphans.length === 0) {
+                output.writeln(output.info('No orphaned project data found.'));
+                return { success: true, message: 'Nothing to clean' };
+            }
+            let removed = 0;
+            for (const o of orphans) {
+                output.writeln(`  ${dryRun ? 'would remove' : 'removing'}: ${o.path}  (${o.description})`);
+                if (!dryRun) {
+                    try {
+                        rmSync(o.path, { recursive: true, force: true });
+                        removed++;
+                    }
+                    catch { /* skip unremovable */ }
+                }
+            }
+            output.writeln();
+            if (dryRun) {
+                output.writeln(output.dim(`  ${orphans.length} item(s). This was a dry run. Use --force to delete.`));
+                return { success: true, message: `Dry run: ${orphans.length} orphaned item(s) found`, data: { found: orphans, dryRun } };
+            }
+            return { success: true, message: `Removed ${removed} orphaned item(s)`, data: { found: orphans, removedCount: removed, dryRun } };
+        }
         if (ctx.flags.scratch === true) {
             const now = Date.now();
             output.writeln();

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -6,6 +6,10 @@ import type { HealthCheck } from './doctor-env-checks.js';
 export type { HealthCheck };
 export declare function checkConfigFile(): Promise<HealthCheck>;
 export declare function checkMemoryDatabase(): Promise<HealthCheck>;
+/** Second Brain: when this project has an indexed knowledge base, semantic
+ * search needs the local embedding model. Its absence is silent (search
+ * degrades to keyword matching) — surface it here instead. */
+export declare function checkSecondBrainModel(): Promise<HealthCheck>;
 export declare function checkApiKeys(): Promise<HealthCheck>;
 export declare function checkMcpServers(): Promise<HealthCheck>;
 export declare function checkMonograph(): Promise<HealthCheck>;

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -44,6 +44,31 @@ export async function checkMemoryDatabase() {
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'monomind memory configure --backend hybrid' };
 }
+/** Second Brain: when this project has an indexed knowledge base, semantic
+ * search needs the local embedding model. Its absence is silent (search
+ * degrades to keyword matching) — surface it here instead. */
+export async function checkSecondBrainModel() {
+    const name = 'Second Brain Model';
+    if (!existsSync(join(process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl'))) {
+        return { name, status: 'pass', message: 'No knowledge base in this project (nothing to check)' };
+    }
+    let pkgDir;
+    try {
+        // exports map blocks package.json — resolve the entry file and walk up
+        const entry = await import.meta.resolve?.('@huggingface/transformers');
+        if (!entry)
+            throw new Error('resolver unavailable');
+        pkgDir = fileURLToPath(entry).replace(/\/dist\/.*$/, '');
+    }
+    catch {
+        return { name, status: 'warn', message: '@huggingface/transformers not installed — semantic search degraded to keyword matching', fix: 'reinstall monomind (the model dependency is optional and may have failed to build)' };
+    }
+    const modelCache = join(pkgDir, '.cache', 'Xenova');
+    if (existsSync(modelCache)) {
+        return { name, status: 'pass', message: 'Local embedding model cached — semantic search active' };
+    }
+    return { name, status: 'warn', message: 'Embedding model not downloaded yet — searches use keyword matching until it is', fix: 'run once while online: monomind doc search -q "warmup" (downloads ~90MB locally, one time)' };
+}
 export async function checkApiKeys() {
     const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
     const found = keys.filter(k => process.env[k]);

package/packages/@monomind/cli/dist/src/commands/doctor.js

@@ -7,7 +7,7 @@
 import * as path from 'path';
 import { output } from '../output.js';
 import { checkNodeVersion, checkNpmVersion, checkGit, checkGitRepo, checkDiskSpace, checkBuildTools, checkVersionFreshness, checkClaudeCode, installClaudeCode, } from './doctor-env-checks.js';
-import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, } from './doctor-project-checks.js';
+import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, checkSecondBrainModel, } from './doctor-project-checks.js';
 import { checkMonoesTools, fixMonoesTools } from './doctor-monoes-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -65,6 +65,7 @@ export const doctorCommand = {
             checkMonograph, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration,
             checkGuidanceGates, checkAgentRegistry, checkGit, checkApiKeys,
             checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings,
+            checkSecondBrainModel,
         ];
         const codeOnlyChecks = [
             checkGitRepo, checkMcpServers,
@@ -78,6 +79,7 @@ export const doctorCommand = {
             node: checkNodeVersion, npm: checkNpmVersion, claude: checkClaudeCode,
             config: checkConfigFile, memory: checkMemoryDatabase,
             api: checkApiKeys, git: checkGit, mcp: checkMcpServers, disk: checkDiskSpace,
+            'second-brain': checkSecondBrainModel,
             typescript: checkBuildTools, monograph: checkMonograph,
             'graph-freshness': checkMonographFreshness, 'memory-pkg': checkMonoesMemory,
             helpers: checkHelpersFresh, monoes: checkMonoesIntegration,