@monoes/monomindcli 2.9.7 → 2.9.8

package/.claude/agents/specialized/specialized-workflow-architect.md

@@ -1,10 +1,9 @@
 ---
 name: Workflow Architect
 description: Workflow design specialist who maps complete workflow trees for every system, user journey, and agent interaction — covering happy paths, all branch conditions, failure modes, recovery paths, handoff contracts, and observable states to produce build-ready specs that agents can implement against and QA can test against.
-color: orange
+color: "#f97316"
 emoji: "\U0001F5FA\uFE0F"
 vibe: Every path the system can take — mapped, named, and specified before a single line is written.
-tools: Read, Write, Edit, WebSearch, WebFetch
 ---
 
 # Workflow Architect Agent Personality

package/.claude/agents/specialized/zk-steward.md

@@ -1,10 +1,9 @@
 ---
 name: ZK Steward
 description: Zettelkasten knowledge-base steward (note-taking system, NOT zero-knowledge cryptography). Manages interconnected atomic notes in Luhmann's slip-box style; switches perspective to domain experts (Feynman, Munger, Ogilvy) by task. Use for personal knowledge management, note linking, complex task breakdown, and cross-domain decision support. For zero-knowledge proofs or ZK cryptography, use zk-steward is WRONG — use security-architect instead.
-color: teal
+color: "#14b8a6"
 emoji: 🗃️
 vibe: Channels Luhmann's Zettelkasten to build connected, validated knowledge bases.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # ZK Steward Agent

package/.claude/agents/testing/production-validator.md

@@ -1,7 +1,6 @@
 ---
 name: production-validator
 description: Production validation specialist ensuring applications are fully implemented and deployment-ready
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Production Validation Agent

package/.claude/agents/testing/tdd-london-swarm.md

@@ -1,7 +1,6 @@
 ---
 name: tdd-london-swarm
 description: TDD London School specialist for mock-driven development within swarm coordination
-tools: Read, Write, Edit, Bash, Glob, Grep
 capability:
   role: tdd-london-swarm
   goal: Drive development from user behavior down to implementation using mock-driven TDD

package/.claude/agents/testing/testing-accessibility-auditor.md

@@ -4,7 +4,6 @@ description: Expert accessibility specialist who audits interfaces against WCAG
 color: "#0077B6"
 emoji: ♿
 vibe: If it's not tested with a screen reader, it's not accessible.
-tools: Read, Write, Edit, Bash, Glob, Grep
 triggers:
   - pattern: "\\b(a11y|accessibility|wcag|aria|screen.?reader|voiceover|nvda|jaws)\\b"
     mode: "inject"

package/.claude/agents/testing/testing-api-tester.md

@@ -1,10 +1,9 @@
 ---
 name: API Tester
 description: Expert API testing specialist focused on comprehensive API validation, performance testing, and quality assurance across all systems and third-party integrations
-color: purple
+color: "#a855f7"
 emoji: 🔌
 vibe: Breaks your API before your users do.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # API Tester Agent Personality

package/.claude/agents/testing/testing-evidence-collector.md

@@ -1,10 +1,9 @@
 ---
 name: Evidence Collector
 description: Screenshot-obsessed, fantasy-allergic QA specialist - Default to finding 3-5 issues, requires visual proof for everything
-color: orange
+color: "#f97316"
 emoji: 📸
 vibe: Screenshot-obsessed QA who won't approve anything without visual proof.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # QA Agent Personality

package/.claude/agents/testing/testing-performance-benchmarker.md

@@ -1,10 +1,9 @@
 ---
 name: Performance Benchmarker
 description: Expert performance testing and optimization specialist focused on measuring, analyzing, and improving system performance across all applications and infrastructure
-color: orange
+color: "#f97316"
 emoji: ⏱️
 vibe: Measures everything, optimizes what matters, and proves the improvement.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Performance Benchmarker Agent Personality

package/.claude/agents/testing/testing-test-results-analyzer.md

@@ -1,10 +1,9 @@
 ---
 name: Test Results Analyzer
 description: Expert test analysis specialist focused on comprehensive test result evaluation, quality metrics analysis, and actionable insight generation from testing activities
-color: indigo
+color: "#6366f1"
 emoji: 📋
 vibe: Reads test results like a detective reads evidence — nothing gets past.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Test Results Analyzer Agent Personality

package/.claude/agents/testing/testing-tool-evaluator.md

@@ -1,10 +1,9 @@
 ---
 name: Tool Evaluator
 description: Expert technology assessment specialist focused on evaluating, testing, and recommending tools, software, and platforms for business use and productivity optimization
-color: teal
+color: "#14b8a6"
 emoji: 🔧
 vibe: Tests and recommends the right tools so your team doesn't waste time on the wrong ones.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Tool Evaluator Agent Personality

package/.claude/agents/testing/testing-workflow-optimizer.md

@@ -1,10 +1,9 @@
 ---
 name: Workflow Optimizer
 description: Expert process improvement specialist focused on analyzing, optimizing, and automating workflows across all business functions for maximum productivity and efficiency
-color: green
+color: "#22c55e"
 emoji: ⚡
 vibe: Finds the bottleneck, fixes the process, automates the rest.
-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Workflow Optimizer Agent Personality

package/.claude/commands/hooks/README.md

@@ -20,7 +20,7 @@ Self-learning hooks system for intelligent workflow automation. Invoked as `npx
 
 ```
 pre-edit          Get context and agent suggestions before editing a file
-post-edit         Record editing outcome for neural pattern learning
+post-edit         Record editing outcome for pattern logging
 pre-command       Assess risk before executing a command
 post-command      Record command execution outcome
 pre-task          Register task start and get agent suggestions + model routing

package/.claude/commands/memory/README.md

@@ -4,13 +4,13 @@ name: memory:README
 
 # Memory Commands
 
-Commands for the LanceDB memory system — vector search, namespaced storage, HNSW indexing, and cross-session persistence.
+Commands for the memory system — local SQLite persistent cache (sql.js/WASM) + local HF embeddings, namespaced storage, keyword fallback search, and cross-session persistence.
 
 ## Available Subcommands
 
 | Subcommand | Description |
 |---|---|
-| `memory init` | Initialize memory backend (lancedb, sqlite, hybrid) |
+| `memory init` | Initialize memory backend (sqlite, hybrid) |
 | `memory store` | Store a memory entry with optional vector embedding |
 | `memory retrieve` | Retrieve a memory entry by key |
 | `memory search` | Search memory (semantic / keyword / hybrid) |
@@ -35,7 +35,7 @@ npx monomind memory init --backend hybrid
 npx monomind memory store --key "auth-pattern" --value "Use JWT with refresh tokens" --namespace "patterns"
 
 # Search
-npx monomind memory search --query "authentication" --type hybrid --build-hnsw
+npx monomind memory search --query "authentication" --type hybrid
 
 # Retrieve exact key
 npx monomind memory retrieve --key "auth-pattern"
@@ -50,7 +50,7 @@ npx monomind memory import --input backup.json --merge
 
 ## Files
 
-- [memory-search.md](./memory-search.md) — Search memory (semantic/keyword/hybrid + HNSW)
+- [memory-search.md](./memory-search.md) — Search memory (semantic/keyword/hybrid; pure-JS HNSW is a dead fallback path, not the default)
 
 ## MCP Tools
 
@@ -68,12 +68,11 @@ npx monomind memory import --input backup.json --merge
 
 | Backend | Description | Recommended |
 |---|---|---|
-| `lancedb` | Full LanceDB with HNSW vector search | Production |
 | `sqlite` | SQLite-only, no vector search | Lightweight |
-| `hybrid` | SQLite + LanceDB HNSW | Default (recommended) |
+| `hybrid` | SQLite + local HF embeddings (keyword fallback; pure-JS HNSW is a dead fallback path, not the default) | Default (recommended) |
 
 ## See Also
 
 - `hooks intelligence` — pattern learning on top of memory
-- `neural` — neural pattern training
+- `neural` — pattern logging
 - `session` — session state (separate from memory)

package/.claude/commands/monitoring/README.md

@@ -13,7 +13,7 @@ Commands for monitoring Monomind system health — swarm status, agents, tasks,
 | `status` | Full system status (swarm, agents, tasks, memory, MCP) |
 | `status agents` | Detailed agent table with uptime and success rate |
 | `status tasks` | Detailed task table with progress and priority |
-| `status memory` | Memory backend stats and HNSW performance |
+| `status memory` | Memory backend stats (SQLite + local embeddings; keyword fallback) |
 | `agent metrics` | Agent performance metrics by type and time period |
 | `agent health` | Per-agent health check with optional watch mode |
 | `swarm status` | Swarm-specific status (topology, consensus, agents) |

package/.claude/helpers/control-start.cjs

@@ -89,7 +89,8 @@ function findCliPath() {
   }
 
   // Try npx monomind as last resort
-  return { cmd: 'npx', args: ['monomind@latest'], usePort: false };
+  const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+  return { cmd: npxCmd, args: ['monomind@latest'], usePort: false };
 }
 
 function readAuthCredential() {
@@ -220,6 +221,13 @@ async function main() {
     env: { ...process.env, CLAUDE_PROJECT_DIR: CWD, MONOMIND_BOUND_REPORT: BOUND_REPORT },
   });
 
+  child.on('error', (err) => {
+    if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") {
+      process.stderr.write(`[control] spawn error: ${err.message}\n`);
+    }
+    releaseSpawnLock();
+  });
+
   child.unref();
 
   // Write optimistic status with DEFAULT_PORT immediately so dependent scripts
@@ -230,8 +238,8 @@ 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".
+  // Resolves to the responder's pid (number), 'foreign-authwalled' for an
+  // auth-gated monomind server, null for unreadable, 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) => {
@@ -240,8 +248,10 @@ async function main() {
         res.on('end', () => {
           if (res.statusCode >= 500) return resolve(false);
           try {
-            const pid = JSON.parse(body).pid;
-            resolve(typeof pid === 'number' ? pid : null);
+            const parsed = JSON.parse(body);
+            if (typeof parsed.pid === 'number') return resolve(parsed.pid);
+            if (res.statusCode === 401 && parsed.error) return resolve('foreign-authwalled');
+            resolve(null);
           } catch { resolve(null); }
         });
       });
@@ -284,7 +294,9 @@ async function main() {
           }
           return;
         }
-        if (p === DEFAULT_PORT && typeof responderPid === 'number') sawForeignOnDefault = true;
+        if (p === DEFAULT_PORT && (typeof responderPid === 'number' || responderPid === 'foreign-authwalled')) {
+          sawForeignOnDefault = true;
+        }
         // pid mismatch or unreadable — not provably ours, keep scanning
       }
     }
@@ -295,7 +307,15 @@ async function main() {
       // and kill our redundant child.
       try { process.kill(child.pid, 'SIGTERM'); } catch { /* already gone */ }
       if (String(process.env.MONOMIND_HOOK_QUIET || "") !== "1") 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);
+      let foreignPid = await probePort(DEFAULT_PORT);
+      if (typeof foreignPid !== 'number' || foreignPid <= 0) {
+        try {
+          const { execFileSync } = require('child_process');
+          const lsofOut = execFileSync('lsof', ['-ti', `:${DEFAULT_PORT}`, '-sTCP:LISTEN'], { encoding: 'utf8', timeout: 3000 }).trim();
+          const parsedPid = parseInt(lsofOut.split('\n')[0], 10);
+          if (Number.isInteger(parsedPid) && parsedPid > 0) foreignPid = parsedPid;
+        } catch { /* ignore */ }
+      }
       writeStatus(typeof foreignPid === 'number' ? foreignPid : 0, DEFAULT_PORT);
       // Pair with the foreign server: resolve its project dir from its pid,
       // copy its dashboard-token beside OUR control.json (ingest is

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

@@ -302,23 +302,42 @@ module.exports = {
       var output = [];
       var conf = result.confidence != null ? result.confidence : 0;
 
-      // ── Persist routing result for statusline display ─────────────
+      // ── Persist routing result for statusline display & outcome correlation ─
       try {
+        var crypto = require('crypto');
+        var routeId = typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : ('route-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8));
         var routeDir = path.join(CWD, '.monomind');
         fs.mkdirSync(routeDir, { recursive: true });
+        var agentName = result.agent || 'coder';
+        var confVal = typeof result.confidence === 'number' ? result.confidence : 0;
+        var promptSlice = (prompt || '').slice(0, 500);
         fs.writeFileSync(
           path.join(routeDir, 'last-route.json'),
           JSON.stringify({
-            agent: result.agent || 'coder',
+            routeId: routeId,
+            agent: agentName,
             agentSlug: result.agentSlug || null,
             confidence: result.confidence,
             reason: result.reason,
-            prompt: (prompt || '').slice(0, 500),
+            prompt: promptSlice,
             historicalPattern: result.historicalPattern || null,
             updatedAt: new Date().toISOString(),
           }),
           'utf-8'
         );
+
+        // Append initial route recommendation to route-outcomes.jsonl
+        var routeRec = {
+          routeId: routeId,
+          ts: Date.now(),
+          task: promptSlice,
+          recommendedAgent: agentName,
+          routingMethod: result.routingMethod || 'keyword',
+          confidence: confVal,
+          learningMode: 'js',
+        };
+        var outcomesPath = path.join(routeDir, 'route-outcomes.jsonl');
+        fs.appendFileSync(outcomesPath, JSON.stringify(routeRec) + '\n', 'utf-8');
       } catch (e) { /* non-fatal */ }
 
       // ── Skill auto-activation (the one thing the hook does better than Claude) ──

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

@@ -101,6 +101,49 @@ module.exports = {
           // Only write the success flag when derived from actual evidence (commits, outcomes)
           if (typeof sessionSuccess === 'boolean') feedbackEntry.intelligenceFeedback = sessionSuccess;
           fs.appendFileSync(feedbackPath, JSON.stringify(feedbackEntry) + '\n', 'utf-8');
+
+          // Also join/record into route-outcomes.jsonl if routeId exists or outcome measured
+          if (typeof sessionSuccess === 'boolean') {
+            try {
+              var routeOutcomesPath = path.join(CWD, '.monomind', 'route-outcomes.jsonl');
+              if (fs.existsSync(routeOutcomesPath)) {
+                var roLines = fs.readFileSync(routeOutcomesPath, 'utf-8').trim().split('\n').filter(Boolean);
+                var updated = false;
+                if (lastRoute.routeId) {
+                  for (var ri = roLines.length - 1; ri >= 0; ri--) {
+                    try {
+                      var roRec = JSON.parse(roLines[ri]);
+                      if (roRec.routeId === lastRoute.routeId) {
+                        roRec.agentActuallyUsed = agentSlug;
+                        roRec.measuredSuccess = sessionSuccess;
+                        roLines[ri] = JSON.stringify(roRec);
+                        updated = true;
+                        break;
+                      }
+                    } catch (_) {}
+                  }
+                }
+                if (!updated) {
+                  // If not found by routeId, join latest unresolved record
+                  for (var ri2 = roLines.length - 1; ri2 >= 0; ri2--) {
+                    try {
+                      var roRec2 = JSON.parse(roLines[ri2]);
+                      if (roRec2.measuredSuccess === undefined) {
+                        roRec2.agentActuallyUsed = agentSlug;
+                        roRec2.measuredSuccess = sessionSuccess;
+                        roLines[ri2] = JSON.stringify(roRec2);
+                        updated = true;
+                        break;
+                      }
+                    } catch (_) {}
+                  }
+                }
+                if (updated) {
+                  fs.writeFileSync(routeOutcomesPath, roLines.join('\n') + '\n', 'utf-8');
+                }
+              }
+            } catch (eRo) { /* non-fatal */ }
+          }
           // Rotate: keep last 1000 lines to prevent unbounded growth.
           try {
             var MAX_FEEDBACK = 512 * 1024; // 512 KiB

package/.claude/helpers/intelligence.cjs

@@ -29,6 +29,21 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MiB guard
 const RING_BUFFER_MAX = 50;
 const MAX_ENTRIES = 200;
 
+// Same list as src/memory/text-tokens.ts's STOPWORDS (inlined — this is a
+// standalone hook script with no access to the TS build). Without this,
+// getContext()'s 2-word-overlap bar counts connector words like "you"/"can"/
+// "the"/"that"/"any" as evidence of relevance, so almost any two prompts
+// spuriously "match" and a stale, unrelated stored entry keeps resurfacing.
+const STOPWORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'but', 'if', 'of', 'to', 'in', 'on', 'at', 'by',
+  'for', 'with', 'from', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'do',
+  'does', 'did', 'doing', 'have', 'has', 'had', 'i', 'we', 'you', 'it', 'its',
+  'that', 'this', 'these', 'those', 'what', 'which', 'who', 'how', 'when', 'where',
+  'why', 'can', 'could', 'should', 'would', 'will', 'my', 'our', 'me', 'us', 'as',
+  'so', 'than', 'then', 'there', 'here', 'not', 'no', 'all', 'any', 'some', 'get',
+  'got', 'about', 'into', 'over', 'out', 'up', 'down', 'again', 'am', 'they',
+]);
+
 var _entries = [];        // deduplicated memory entries loaded from store
 var _recentEdits = [];    // ring buffer of recently edited paths (in-memory, may be empty across subprocesses)
 var _lastContext = null;  // last non-null context returned by getContext()
@@ -163,7 +178,7 @@ function getContext(prompt) {
   if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') return null;
   if (_entries.length === 0) return null;
 
-  var promptWords = prompt.toLowerCase().split(/\W+/).filter(function(w) { return w.length >= 3; });
+  var promptWords = prompt.toLowerCase().split(/\W+/).filter(function(w) { return w.length >= 3 && !STOPWORDS.has(w); });
   var promptSet = new Set(promptWords);
   if (promptSet.size < 2) return null; // need at least 2 meaningful words
 
@@ -171,11 +186,15 @@ function getContext(prompt) {
   for (var i = 0; i < _entries.length; i++) {
     var e = _entries[i];
     var content = ((e.content || '') + ' ' + (e.summary || '')).toLowerCase();
-    var words = content.split(/\W+/).filter(function(w) { return w.length >= 3; });
+    var words = content.split(/\W+/).filter(function(w) { return w.length >= 3 && !STOPWORDS.has(w); });
+    // Count DISTINCT overlapping words, not raw occurrences — content and
+    // summary commonly repeat the same filenames, so a single shared word
+    // (e.g. "review" in both a file's name and its own summary restating it)
+    // was inflating hits to 2+ on its own, undermining the "distinct" bar
+    // this comment already promised.
+    var entrySet = new Set(words);
     var hits = 0;
-    for (var j = 0; j < words.length; j++) {
-      if (promptSet.has(words[j])) hits++;
-    }
+    promptSet.forEach(function(w) { if (entrySet.has(w)) hits++; });
     // Require at least 2 distinct word matches to reduce false positives
     if (hits >= 2) {
       scored.push({ entry: e, hits: hits });
@@ -191,7 +210,9 @@ function getContext(prompt) {
   });
 
   var top = scored[0].entry;
-  var result = '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
+  var text = String(top.summary || top.content || top.id || 'context match');
+  if (text.length > 160) text = text.slice(0, 160) + '…';
+  var result = '[INTELLIGENCE] ' + text;
   _lastContext = result;
   return result;
 }

package/.claude/helpers/statusline.cjs

@@ -932,9 +932,18 @@ function getHILPending() {
   return { pending };
 }
 
-// Active org runs — scan .monomind/orgs/*/runs/*.jsonl for recent activity
-// Also checks .git/monomind/orgs/ (git-safe path used by mastermind orgs).
-// An org is "active" if it has an events file modified within the last 10 minutes.
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Active org runs — scan .monomind/orgs/*/runtime.json (Org Runtime v2)
+// and fallback to .monomind/orgs/*/runs/*.jsonl / <runId>/bus.jsonl.
 function getActiveOrgs() {
   // Try git-common-dir path first (mastermind orgs store run files there)
   let orgsDir = path.join(CWD, '.monomind', 'orgs');
@@ -954,31 +963,54 @@ function getActiveOrgs() {
   try {
     const orgNames = fs.readdirSync(orgsDir).filter(f => !f.startsWith('.'));
     for (const orgName of orgNames.slice(0, 20)) {
-      const runsDir = path.join(orgsDir, orgName, 'runs');
-      if (!fs.existsSync(runsDir)) continue;
+      const orgPath = path.join(orgsDir, orgName);
+      const runtimePath = path.join(orgPath, 'runtime.json');
+      // 1) Org Runtime v2: runtime.json is authoritative
+      if (fs.existsSync(runtimePath)) {
+        try {
+          const stat = safeStat(runtimePath);
+          const age = stat ? now - stat.mtimeMs : 0;
+          const data = readJSON(runtimePath);
+          if (data && typeof data === 'object') {
+            const isRunning = data.status === 'running' && (typeof data.pid === 'number' ? isPidAlive(data.pid) : age < STALE_MS);
+            if (isRunning || age < STALE_MS) {
+              active.push({
+                name: orgName,
+                runId: typeof data.run === 'string' ? data.run : 'active',
+                ageMs: age,
+                running: isRunning,
+              });
+              continue;
+            }
+          }
+        } catch { /* fallback to directory scan */ }
+      }
+
+      // 2) Fallback: scan runs/ or <runId>/bus.jsonl
+      const runsDir = path.join(orgPath, 'runs');
+      const scanDir = fs.existsSync(runsDir) ? runsDir : orgPath;
       try {
-        const files = cleanEntries(runsDir, f => f.endsWith('.jsonl'));
+        const files = cleanEntries(scanDir, f => f.endsWith('.jsonl') || f.endsWith('bus.jsonl'));
         if (!files.length) continue;
         files.sort();
         const latest = files[files.length - 1];
-        const stat = safeStat(path.join(runsDir, latest));
+        const stat = safeStat(path.join(scanDir, latest));
         if (!stat) continue;
         const age = now - stat.mtimeMs;
         if (age < STALE_MS) {
-          // Check last event type to determine if still running
           let isRunning = true;
           try {
             const MAX_RUN = 512 * 1024; // 512 KiB
             if (stat.size <= MAX_RUN) {
-              const raw = fs.readFileSync(path.join(runsDir, latest), 'utf-8');
+              const raw = fs.readFileSync(path.join(scanDir, latest), 'utf-8');
               const lines = raw.trim().split('\n').filter(Boolean);
               if (lines.length) {
                 const lastEv = JSON.parse(lines[lines.length - 1]);
-                if (lastEv.type === 'run:complete' || lastEv.type === 'org:complete') isRunning = false;
+                if (lastEv.type === 'run:complete' || lastEv.type === 'org:complete' || (lastEv.type === 'status' && lastEv.msg === 'org stopped')) isRunning = false;
               }
             }
           } catch { /* treat as running */ }
-          active.push({ name: orgName, runId: latest.replace('.jsonl', ''), ageMs: age, running: isRunning });
+          active.push({ name: orgName, runId: latest.replace('.jsonl', '').replace('/bus', ''), ageMs: age, running: isRunning });
         }
       } catch { /* skip */ }
     }
@@ -1406,6 +1438,7 @@ function generateJSON() {
     tests:      getTestStats(),
     git:        { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
     tokenCost:  getTokenCostSummary(),
+    activeOrgs: getActiveOrgs(),
     lastUpdated: new Date().toISOString(),
   };
 }
@@ -1429,6 +1462,7 @@ if (require.main !== module) {
     getSecurityStatus, getSwarmStatus, getADRStatus,
     getHooksStatus, getActiveAgent, getLanceDBStats,
     getLearningStats, getTestStats, getIntegrationStatus,
+    getActiveOrgs,
     generateJSON,
   };
 }

package/.claude/skills/agentic-jujutsu/SKILL.md

@@ -1,24 +1,24 @@
 ---
 name: agentic-jujutsu
 description: |
-  Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
+  Self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination. Wraps the separate `agentic-jujutsu` npm package.
 ---
 
 # Agentic Jujutsu - AI Agent Version Control
 
-> Quantum-ready, self-learning version control designed for multiple AI agents working simultaneously without conflicts.
+> Self-learning version control designed for multiple AI agents working simultaneously without conflicts.
 
 ## When to Use This Skill
 
 Use **agentic-jujutsu** when you need:
 - Multiple AI agents modifying code simultaneously
-- Lock-free version control (23x faster than Git)
+- Lock-free version control
 - Self-learning AI that improves from experience
-- Quantum-resistant security for future-proof protection
-- Automatic conflict resolution (87% success rate)
 - Pattern recognition and intelligent suggestions
 - Multi-agent coordination without blocking
 
+> **Note:** this skill wraps the separate `agentic-jujutsu` npm package. Performance and feature claims should be verified against that package's own documentation before relying on them.
+
 ## Quick Start
 
 ### Installation
@@ -143,9 +143,9 @@ const similar = JSON.parse(tester.queryTrajectories('test feature', 5));
 console.log(`Found ${similar.length} similar test approaches`);
 ```
 
-### 5. Quantum-Resistant Security (v2.3.0+)
+### 5. Cryptographic Integrity (v2.3.0+)
 
-Fast integrity verification with quantum-resistant cryptography:
+Fast integrity verification with SHA3-512 hashing:
 
 ```javascript
 const { generateQuantumFingerprint, verifyQuantumFingerprint } = require('agentic-jujutsu');
@@ -405,7 +405,7 @@ for (let i = 1; i <= 10; i++) {
 | `getUserOperations(limit)` | Get user operations only | JjOperation[] |
 | `clearLog()` | Clear operation log | void |
 
-### Quantum Security Methods (v2.3.0+)
+### Cryptographic Methods (v2.3.0+)
 
 | Method | Description | Returns |
 |--------|-------------|---------|
@@ -417,13 +417,15 @@ for (let i = 1; i <= 10; i++) {
 
 ## Performance Characteristics
 
-| Metric | Git | Agentic Jujutsu |
+> The following figures are **vendor-published for the `agentic-jujutsu` npm package and not independently verified by monomind**. Treat as marketing claims until you benchmark against your own workload.
+
+| Metric | Git | Agentic Jujutsu (vendor-claimed) |
 |--------|-----|-----------------|
-| Concurrent commits | 15 ops/s | 350 ops/s (23x) |
-| Context switching | 500-1000ms | 50-100ms (10x) |
-| Conflict resolution | 30-40% auto | 87% auto (2.5x) |
-| Lock waiting | 50 min/day | 0 min (∞) |
-| Quantum fingerprints | N/A | <1ms |
+| Concurrent commits | 15 ops/s | 350 ops/s (claimed ~23x) |
+| Context switching | 500-1000ms | 50-100ms (claimed ~10x) |
+| Conflict resolution | 30-40% auto | 87% auto (claimed ~2.5x) |
+| Lock waiting | 50 min/day | 0 min (claimed) |
+| SHA3-512 fingerprints | N/A | <1ms |
 
 ## Best Practices
 
@@ -634,7 +636,7 @@ async function agentSwarm(taskList) {
 
 - **v2.3.2** - Documentation updates
 - **v2.3.1** - Validation fixes for ReasoningBank
-- **v2.3.0** - Quantum-resistant security with @qudag/napi-core
+- **v2.3.0** - Cryptographic security (SHA3-512) with @qudag/napi-core
 - **v2.1.0** - Self-learning AI with ReasoningBank
 - **v2.0.0** - Zero-dependency installation with embedded jj binary