@monoes/monomindcli 2.9.6 → 2.9.8

package/.claude/skills/hooks-automation/SKILL.md

@@ -23,7 +23,7 @@ This skill provides a comprehensive hook system that automatically manages devel
 ## Prerequisites
 
 **Required:**
-- Monomind CLI installed (`npm install -g monomind@alpha`)
+- Monomind CLI installed (`npm install -g monomind@latest`)
 - Claude Code with hooks enabled
 - `.claude/settings.json` with hook configurations
 

package/.claude/skills/mastermind-adapters/SKILL.md

@@ -134,17 +134,6 @@ echo "Installed: $package_name as adapter type '$adapter_type'"
 echo "NOTE: Restart the org run to activate the new adapter."
 ```
 
-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" -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
-```
-
 ### remove
 
 ```bash

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

@@ -124,17 +124,6 @@ jq --arg id "$agent_id" \
 echo "Hired: $title ($agent_type) → adapter: $adapter_model"
 ```
 
-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" -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
-```
-
 ### pause / resume
 
 <!-- LEGACY-ORG-V1: the agent state/heartbeat file this pauses is a v1 concept. -->

package/.claude/skills/mastermind-backup/SKILL.md

@@ -88,17 +88,6 @@ else
 fi
 ```
 
-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" -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
-```
-
 ### list
 
 Show all available backups:

package/.claude/skills/mastermind-bootstrap/SKILL.md

@@ -146,17 +146,6 @@ Use your INVITE_TOKEN for your first heartbeat. Token is single-use.
 PRIMER
 ```
 
-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" -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
-```
-
 ### reset
 
 Clear bootstrap state (next init will regenerate token):

package/.claude/skills/mastermind-delegation/SKILL.md

@@ -26,22 +26,24 @@ You have full access to the Agent tool (Claude Code: Task tool) to spawn
 sub-agents for any specialized subtask. This capability is recursive —
 sub-agents you spawn also receive it.
 
-Available agent categories (use the exact slug or name):
+Available agent categories (use the exact slug or name — all of these exist on disk):
 
   CORE      coder · reviewer · tester · planner · researcher
-  BACKEND   backend-dev · Backend Architect · DB Optimizer · API Tester
+  BACKEND   Backend Architect · Database Optimizer · API Tester
   FRONTEND  Frontend Developer · mobile-dev · Mobile App Builder
-  ARCH      Software Architect · system-architect
-  SECURITY  Security Engineer · security-architect
-  AI/ML     AI Engineer · ml-developer · Data Engineer
-  DEVOPS    DevOps Automator · SRE · cicd-engineer
-  DOCS      Technical Writer · api-docs
-  PRODUCT   Product Manager · Launch Strategist · CRO Specialist
-  MARKETING Content Creator · SEO Specialist · Growth Hacker · Email Marketing
-  SOCIAL    TikTok · LinkedIn · Twitter · Instagram Strategist
-  SALES     Deal Strategist · Sales Coach · Outbound Strategist
-  BUSINESS  Finance Tracker · Legal Compliance Checker · Analytics Reporter
+  ARCH      Software Architect · system-architect · Backend Architect
+  SECURITY  Security Engineer · Compliance Auditor · Blockchain Security Auditor · Threat Detection Engineer
+  AI/ML     AI Engineer · Data Engineer · AI Data Remediation Engineer · Model QA Specialist
+  DEVOPS    DevOps Automator · SRE (Site Reliability Engineer) · Git Workflow Master · Incident Response Commander
+  DOCS      Technical Writer
+  MARKETING Competitive Content Strategist · CRO Specialist · Email Marketing Specialist · Launch Strategist · Pricing Strategist
+  SPECIALIZED  MCP Builder · Document Generator · LSP/Index Engineer · Embedded Firmware Engineer · Solidity Smart Contract Engineer
+  GITHUB    pr-manager · issue-tracker · code-review-swarm · release-manager
   DESIGN    Monodesign (UI/UX · brand · CSS · animation · design systems)
+  SWARM     mesh-coordinator · coordinator · Agents Orchestrator
+
+The authoritative list is the filesystem — run `ls .claude/agents/` for the full
+~98-agent set. Do NOT invent agent names; only delegate to agents that exist.
 
 WHEN to delegate:
 - A subtask needs deeper expertise than your primary role

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

@@ -1079,7 +1079,6 @@ MONO_DIR=$(_get_mono_dir "$REPO_ROOT")
 SESSION_ID=$(jq -r '.sessionId // empty' "$MONO_DIR/sessions/current.json" 2>/dev/null)
 if [ -n "$SESSION_ID" ]; then
   mkdir -p "$MONO_DIR/sessions/${SESSION_ID}"
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
   # LLM: substitute <status>: complete (all steps ran), partial (some skipped), blocked (critical error)
   # LLM: substitute next_actions with actual suggestions derived from this run's top ideas
   jq -n \
@@ -1089,10 +1088,6 @@ 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" -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
 fi
 ```
 

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

@@ -379,15 +379,8 @@ tmp="${cfg}.tmp"
 jq --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '.last_tick = $ts' "$cfg" > "$tmp" && mv "$tmp" "$cfg"
 ```
 
-**Emit dashboard 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")
 SESSION_ID="monitor-${name}-$(date -u +%Y%m%dT%H%M%S)"
-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
 ```
 
 **Poll each source (in order, stop after first claimable task found):**
@@ -957,14 +950,6 @@ tmp="${cfg}.tmp"
 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" -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
-```
-
 ```bash
 else  # result_status != "done"
 ```

package/.claude/skills/mastermind-org-settings/SKILL.md

@@ -159,17 +159,6 @@ npx -y monomind@latest org validate "$org_name" \
   || echo "WARNING: '${org_name}' no longer passes validation — fix it before 'monomind org run ${org_name}'"
 ```
 
-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" -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
-```
-
 ### export
 
 Export the full org config (minus secrets) to a portable JSON:

package/.claude/skills/mastermind-plugins/SKILL.md

@@ -125,17 +125,6 @@ echo "Installed: $package_name (id: $pluginId)"
 echo "NOTE: Agents must be restarted to load the new plugin."
 ```
 
-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" -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
-```
-
 ### uninstall
 
 ```bash

package/.claude/skills/mastermind-protocol/SKILL.md

@@ -29,12 +29,12 @@ This makes delegation recursive: every spawned agent can itself spawn sub-agents
 Execute at the START of every mastermind run (master or standalone domain command). Load in this order:
 
 **Step A — Tier 3 core principles (all domains):**
-Try `mcp__monomind__lancedb_hierarchical-recall` with query `"mastermind principles"`, topK 20.
+Try `mcp__monomind__memory_hierarchical-recall` with query `"mastermind principles"`, topK 20.
 If it returns `"LanceDB bridge not available"` or any error, fall back to:
 `mcp__monomind__memory_search` with query `"mastermind principles"`, namespace `"mastermind:principles"`, limit 20.
 
 **Step B — Tier 2 weekly summary for this domain:**
-Try `mcp__monomind__lancedb_context-synthesize` with query `[current prompt keywords]`, maxEntries 10.
+Try `mcp__monomind__memory_context-synthesize` with query `[current prompt keywords]`, maxEntries 10.
 If it fails, fall back to:
 `mcp__monomind__memory_search` with query `[current prompt keywords]`, namespace `"mastermind:<domain>:weekly"`, limit 10.
 
@@ -69,7 +69,7 @@ score = confidence × (1 / (days_since_run + 1)) × log(uses + 1)
 - `uses`: 1 (first write)
 
 **Step 2 — Append to Tier 1 raw log:**
-Try `mcp__monomind__lancedb_hierarchical-store` with:
+Try `mcp__monomind__memory_hierarchical-store` with:
 - namespace: `mastermind:<domain>:raw`
 - content: [full unified output schema YAML from this run, as a string]
 - metadata: `{ score, project, run_id, date: ISO8601, domain }`
@@ -81,19 +81,19 @@ If LanceDB is unavailable, fall back to `mcp__monomind__memory_store`:
 - tags: `["mastermind", "<domain>", "run"]`
 
 **Step 3 — Check weekly compaction trigger:**
-Try `mcp__monomind__lancedb_health` on namespace `mastermind:<domain>:raw`.
+Try `mcp__monomind__memory_health` on namespace `mastermind:<domain>:raw`.
 If unavailable, call `mcp__monomind__memory_stats` and check entry count manually.
 If `entry_count >= 20` OR `days_since_last_compaction >= 7`:
 1. Retrieve all Tier 1 entries since last compaction
 2. Produce a per-domain weekly summary (use LLM synthesis: "Summarize the key decisions, patterns, and lessons from these run logs in under 300 words")
-3. Store summary: `mcp__monomind__lancedb_hierarchical-store` namespace `mastermind:<domain>:weekly`
+3. Store summary: `mcp__monomind__memory_hierarchical-store` namespace `mastermind:<domain>:weekly`
 4. Archive (do not delete) Tier 1 entries with score < 0.1 by updating their metadata: `{ archived: true }`
 
 **Step 4 — Check graph consolidation trigger:**
 Call `mcp__monomind__monograph_community` for nodes matching `mastermind:<domain>`.
 If 3+ similar memory nodes are detected in a cluster:
 1. Merge into a single principle via LLM: "Distill these memories into one clear principle in 1-2 sentences"
-2. Store principle: `mcp__monomind__lancedb_hierarchical-store` namespace `mastermind:principles`
+2. Store principle: `mcp__monomind__memory_hierarchical-store` namespace `mastermind:principles`
 3. Add `EXCEPTION` edge in Monograph for any conflicting memory: `mcp__monomind__monograph_add_fact`
 
 ---
@@ -142,124 +142,6 @@ score = confidence × (1 / (days_since_run + 1)) × log(uses + 1)
 
 ---
 
-## Real-Time Dashboard Event Logging
-
-Every mastermind run MUST emit structured events to the live dashboard via curl (NOT WebFetch — WebFetch is blocked for localhost in Claude Code runtimes). The dashboard at `docs/mastermind-diagram.html` listens on SSE and animates each event in real time.
-
-**Dashboard endpoint:** `<CTRL_URL>/api/mastermind/event`
-Resolve `CTRL_URL` at runtime: `jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242"` — the control server port auto-increments on collision and writes the actual URL to `.monomind/control.json`.
-**Method:** POST, `Content-Type: application/json`
-
-### Event Types and When to Emit
-
-**1. session:start** — emit at the very start of Step 3 (Intake) once the prompt is resolved:
-```json
-{
-  "type": "session:start",
-  "session": "<uuid-v4>",
-  "prompt": "<resolved user prompt>",
-  "mode": "auto|confirm",
-  "project": "<absolute path of current working directory>",
-  "ts": 1234567890000
-}
-```
-
-**2. domain:dispatch** — emit once per domain BEFORE spawning the domain manager agent:
-```json
-{
-  "type": "domain:dispatch",
-  "session": "<same-uuid>",
-  "domain": "build|marketing|review|research|content|release|sales|ops|finance|idea",
-  "cmd": "<one-line description of what this domain will do>",
-  "ts": 1234567890000
-}
-```
-
-**3. agent:spawn** — domain managers MUST emit this when they spawn each specialized agent:
-```json
-{
-  "type": "agent:spawn",
-  "session": "<same-uuid>",
-  "domain": "<domain-id>",
-  "agent": "<agent-slug, e.g. backend-dev>",
-  "task": "<task description>",
-  "ts": 1234567890000
-}
-```
-
-**4. intercom** — emit when a domain manager or agent sends output/context to another domain:
-```json
-{
-  "type": "intercom",
-  "session": "<same-uuid>",
-  "from": "<domain-id>",
-  "to": "<domain-id>",
-  "msg": "<one-line summary of what was transferred>",
-  "ts": 1234567890000
-}
-```
-
-**5. domain:complete** — emit when a domain manager returns its unified output schema:
-```json
-{
-  "type": "domain:complete",
-  "session": "<same-uuid>",
-  "domain": "<domain-id>",
-  "status": "complete|partial|blocked",
-  "artifacts": ["<path1>", "<path2>"],
-  "decisions": [{"what": "...", "confidence": 0.9}],
-  "ts": 1234567890000
-}
-```
-
-**6. session:complete** — emit at the end of Step 9 (Synthesize) after all domains have reported:
-```json
-{
-  "type": "session:complete",
-  "session": "<same-uuid>",
-  "status": "complete|partial|blocked",
-  "domains": ["build", "marketing"],
-  "ts": 1234567890000
-}
-```
-
-### How to Emit (curl-first — WebFetch is blocked for localhost in Claude Code runtimes)
-
-**Always use curl via Bash.** WebFetch is restricted for `localhost` URLs in Claude Code agent runtimes and will return ECONNREFUSED even when the server is running. **Always resolve the control URL dynamically** — the server auto-increments the port on collision. Use this pattern:
-
-```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" -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 type "session:start" \
-    --arg prompt "$resolved_prompt" \
-    --arg mode "$mode" \
-    --arg proj "$(pwd)" \
-    '{type:$type,session:$sid,prompt:$prompt,mode:$mode,project:$proj,ts:(now*1000|floor)}')" || true
-```
-
-**Always append `|| true`** — event emission is non-blocking and MUST NOT abort the run.
-
-**If Bash is unavailable** (e.g. the agent type has no Bash tool): skip dashboard events entirely. They are observability-only and do not affect pipeline correctness. The master context always has Bash and emits session:start, domain:dispatch, and session:complete on behalf of the run.
-
-**Session ID:** Generate once at session:start and reuse across all subsequent events for this run. A simple ID format: `mm-<ISO8601-compact>` (e.g. `mm-20260505T142300`).
-
-### Where Each Role Emits
-
-| Role | Events to emit |
-|---|---|
-| **Master** (master.md Step 3) | `session:start` |
-| **Master** (master.md Step 7, per domain) | `domain:dispatch` × N |
-| **Master** (master.md Step 9) | `session:complete` |
-| **Domain Manager** (on agent spawn) | `agent:spawn` × M |
-| **Domain Manager** (on cross-domain handoff) | `intercom` |
-| **Domain Manager** (on return) | `domain:complete` |
-
----
-
 ## Monotask Space+Board Setup Procedure
 
 **Always follow this exact order — never create a board without first ensuring a space exists.**

package/.claude/skills/mastermind-repeat/SKILL.md

@@ -69,14 +69,6 @@ Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment
   [tillend] Empty round — nothing found, nothing changed in run <current_rep>.
   /<command> tillend loop complete (ran <current_rep> run(s)).
   ```
-- Emit dashboard event (non-fatal if control server is not running):
-  ```bash
-  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
-  curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "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
-  ```
 - Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
 - **END**.
 
@@ -99,14 +91,6 @@ Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment
 
 If `current_rep >= repeat_count`:
 - Output: `[repeat] All <repeat_count> runs of /<command> complete.`
-- Emit dashboard 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" -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
-  ```
 - Run: `rm -f ".monomind/loops/${LOOP_ID}.json"`
 - **END**.
 
@@ -147,15 +131,6 @@ cat > ".monomind/loops/${LOOP_ID}.json" << EOF
 EOF
 ```
 
-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" -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
-```
-
 **Call `ScheduleWakeup` now** — this is a mandatory tool call:
 
 - **Tillend mode**:

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

@@ -134,7 +134,7 @@ Spawn one Task agent per review angle (mesh topology — reviewers share finding
 ```
 MONOFENCE SELF-CHECK (monofence_check flag):
 Run the test suite and adversarial probes against the live monofence-ai detector.
-1. cd packages/@monomind/monodefence && npx vitest run — report any failures as Critical
+1. cd packages/monofence-ai && npx vitest run — report any failures as Critical
 2. Feed known attack strings through detect() and assert correct threat types/confidence:
    - "ignore all previous instructions" → expect prompt_injection ≥ 0.8
    - "іgnore" (Cyrillic і) → expect homoglyph wasObfuscated=true

package/.claude/skills/mastermind-stoporg/SKILL.md

@@ -90,25 +90,6 @@ touch ".monomind/orgs/.stops/${org_name}.stop"
 
 ---
 
-<!-- LEGACY-ORG-V1: remove this step when v1 orgs are gone -->
-## Step 4 — Emit Dashboard Events
-
-```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")
-
-# org:stop — signals dashboard to update status to stopped
-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}" \
-    --arg org "$org_name" \
-    --arg proj "$REPO_ROOT" \
-    '{type:"org:stop",session:$session,org:$org,project:$proj,ts:(now*1000|floor)}')" || true
-```
-
----
-
 <!-- LEGACY-ORG-V1: remove this step when v1 orgs are gone -->
 ## Step 5 — Report to User (v1 only)
 

package/.claude/skills/memory-toolkit/SKILL.md

@@ -1,18 +1,20 @@
 ---
 name: memory-toolkit
 description: >
-  Use monomind's persistent memory store (LanceDB + pure-JS HNSW) to save,
-  search, list, and retrieve cross-session knowledge — patterns, solutions,
-  decisions. Trigger on "remember this", "store in memory", "search memory",
-  "have we solved this before", "recall past decisions", or before starting
-  work that benefits from prior context (debugging, refactors, repeated tasks).
+  Use monomind's persistent memory store (local SQLite + local embeddings) to
+  save, search, list, and retrieve cross-session knowledge — patterns,
+  solutions, decisions. Trigger on "remember this", "store in memory",
+  "search memory", "have we solved this before", "recall past decisions", or
+  before starting work that benefits from prior context (debugging,
+  refactors, repeated tasks).
 ---
 
 # Memory Toolkit
 
-Monomind ships a persistent, namespaced memory store backed by LanceDB with
-a pure-JS HNSW index for approximate nearest-neighbor vector search. Use it
-to avoid re-solving the same problem twice across sessions.
+Monomind ships a persistent, namespaced memory store backed by local SQLite
+(sql.js/WASM) with local HF embeddings; keyword search is the fallback when
+embeddings aren't available. Use it to avoid re-solving the same problem
+twice across sessions.
 
 ## Before starting non-trivial work
 
@@ -46,9 +48,8 @@ npx monomind memory search --query "error handling" --namespace patterns --limit
 | `keyword`   | BM25 full-text search          | Exact term matching        |
 | `hybrid`    | Combined semantic + keyword    | General purpose (default)  |
 
-Use `--build-hnsw` before searching large memory stores (1,000+ entries) —
-it builds a pure-JS HNSW index for O(log n) queries instead of O(n) linear
-scan (one-time build cost).
+`--build-hnsw` is a dead fallback: it's a no-op unless the SQLite bridge is
+down and the sql.js WASM path is in use. Normal searches don't need it.
 
 ## List and retrieve
 

package/.claude/skills/monodesign/scripts/detector/engines/browser/drivers.mjs

@@ -143,7 +143,14 @@ async function launchMonobrowseBrowser(options = {}) {
     if (port === null) throw new Error('Could not find a free CDP port for monobrowse');
   }
 
-  const launchedPort = await mb.launchBrowser({ port, headless, args: launchArgs });
+  // CI runners (observed on the Windows GH Actions runner) are slower to get
+  // Chrome's CDP port open than the 10s default — a batch of sequential
+  // headless launches in the same job intermittently misses that window and
+  // fails with "Chrome failed to start... within 10000ms" even though the
+  // browser starts fine, just later. Give CI more runway; local dev keeps
+  // the tighter default so a genuinely broken launch still fails fast.
+  const launchTimeoutMs = options.launchTimeoutMs ?? (process.env.CI ? 30000 : undefined);
+  const launchedPort = await mb.launchBrowser({ port, headless, args: launchArgs, launchTimeoutMs });
   // Control connection (to the initial about:blank tab) — used for lifecycle
   // commands; detection pages get their own dedicated connections.
   const control = await mb.connectToTarget(launchedPort);

package/.claude/skills/pair-programming/SKILL.md

@@ -22,7 +22,7 @@ This skill provides professional pair programming capabilities with AI assistanc
 ## Prerequisites
 
 **Required:**
-- Monomind CLI installed (`npm install -g monomind@alpha`)
+- Monomind CLI installed (`npm install -g monomind@latest`)
 - Git repository (optional but recommended)
 
 **Recommended:**