monomind 1.11.9 → 1.11.10

package/.claude/helpers/intelligence.cjs

@@ -0,0 +1,87 @@
+'use strict';
+/**
+ * Intelligence context module for hook-handler.cjs
+ * Provides context injection, trajectory logging, and feedback recording.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const INTEL_DIR = path.join(CWD, '.monomind', 'intelligence');
+const PATTERNS_FILE = path.join(INTEL_DIR, 'patterns.json');
+const TRAJECTORY_FILE = path.join(INTEL_DIR, 'trajectory.json');
+
+var _initialized = false;
+var _patterns = [];
+var _trajectory = [];
+
+function ensureDir() {
+  try { fs.mkdirSync(INTEL_DIR, { recursive: true }); } catch (_) {}
+}
+
+function loadPatterns() {
+  try {
+    if (fs.existsSync(PATTERNS_FILE)) {
+      _patterns = JSON.parse(fs.readFileSync(PATTERNS_FILE, 'utf-8'));
+    }
+  } catch (_) { _patterns = []; }
+}
+
+function init() {
+  if (_initialized) return { ok: true, patternCount: _patterns.length };
+  ensureDir();
+  loadPatterns();
+  _initialized = true;
+  return { ok: true, patternCount: _patterns.length };
+}
+
+function getContext(prompt) {
+  if (!prompt || typeof prompt !== 'string') return null;
+  if (!_initialized) init();
+  // Match patterns against prompt
+  var matches = _patterns.filter(function(p) {
+    return p.keywords && p.keywords.some(function(kw) {
+      return prompt.toLowerCase().includes(kw.toLowerCase());
+    });
+  });
+  if (matches.length === 0) return null;
+  var top = matches[0];
+  return '[INTELLIGENCE] Pattern match: ' + (top.name || top.id || 'pattern') +
+         (top.suggestion ? ' — ' + top.suggestion : '');
+}
+
+function logTrajectory(step) {
+  ensureDir();
+  _trajectory.push(Object.assign({ ts: new Date().toISOString() }, step || {}));
+  // Flush every 10 steps to avoid excessive writes
+  if (_trajectory.length % 10 === 0) {
+    try {
+      fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
+    } catch (_) {}
+  }
+}
+
+function feedback(success) {
+  // Record outcome for last trajectory step
+  if (_trajectory.length > 0) {
+    _trajectory[_trajectory.length - 1].outcome = success ? 'success' : 'failure';
+  }
+  // Persist
+  ensureDir();
+  try {
+    fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+function storePattern(pattern) {
+  ensureDir();
+  loadPatterns();
+  _patterns = _patterns.filter(function(p) { return p.id !== pattern.id; });
+  _patterns.push(Object.assign({ storedAt: new Date().toISOString() }, pattern));
+  try {
+    fs.writeFileSync(PATTERNS_FILE, JSON.stringify(_patterns.slice(-500), null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+module.exports = { init, getContext, logTrajectory, feedback, storePattern };

package/.claude/helpers/learning-service.mjs

@@ -0,0 +1,60 @@
+/**
+ * LearningService — session-scoped learning consolidation
+ * Used as a module-level singleton by hook-handler.cjs (getLearningService()).
+ *
+ * Contract:
+ *   new LearningService()
+ *   await svc.initialize()   — open DB / load state
+ *   await svc.consolidate()  — flush accumulated learnings to persistent store
+ */
+
+import path from 'path';
+import fs from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const LEARN_DIR = path.join(CWD, '.monomind', 'learning');
+const LEARN_FILE = path.join(LEARN_DIR, 'session-learnings.json');
+
+export class LearningService {
+  constructor() {
+    this._entries = [];
+    this._initialized = false;
+  }
+
+  async initialize() {
+    try {
+      mkdirSync(LEARN_DIR, { recursive: true });
+      if (existsSync(LEARN_FILE)) {
+        const raw = await fs.readFile(LEARN_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        this._entries = Array.isArray(data) ? data : [];
+      }
+    } catch (_) {
+      this._entries = [];
+    }
+    this._initialized = true;
+  }
+
+  record(entry) {
+    if (!this._initialized) return;
+    this._entries.push(Object.assign({ ts: new Date().toISOString() }, entry));
+  }
+
+  async consolidate() {
+    if (!this._initialized || this._entries.length === 0) return;
+    try {
+      mkdirSync(LEARN_DIR, { recursive: true });
+      // Keep last 1000 entries
+      const trimmed = this._entries.slice(-1000);
+      await fs.writeFile(LEARN_FILE, JSON.stringify(trimmed, null, 2), 'utf-8');
+      this._entries = trimmed;
+    } catch (_) {}
+  }
+
+  getEntries() {
+    return this._entries.slice();
+  }
+}
+
+export default { LearningService };

package/.claude/helpers/memory.cjs

@@ -0,0 +1,69 @@
+'use strict';
+/**
+ * Memory context bridge for hook-handler.cjs
+ * Bridges to the CLI memory subsystem via file-based storage fallback.
+ * Used by handlers to retrieve relevant context and store outcomes.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const MEMORY_DIR = path.join(CWD, '.monomind', 'memory');
+const MEMORY_INDEX = path.join(MEMORY_DIR, 'hook-memory.json');
+
+function ensureDir() {
+  try { fs.mkdirSync(MEMORY_DIR, { recursive: true }); } catch (_) {}
+}
+
+function loadIndex() {
+  try {
+    if (!fs.existsSync(MEMORY_INDEX)) return [];
+    return JSON.parse(fs.readFileSync(MEMORY_INDEX, 'utf-8'));
+  } catch (_) {
+    return [];
+  }
+}
+
+function saveIndex(entries) {
+  ensureDir();
+  try {
+    // Keep most recent 500 entries
+    var trimmed = entries.slice(-500);
+    fs.writeFileSync(MEMORY_INDEX, JSON.stringify(trimmed, null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+function store(key, value, namespace) {
+  var entries = loadIndex();
+  var ns = namespace || 'default';
+  // Remove existing entry with same key+namespace
+  entries = entries.filter(function(e) { return !(e.key === key && e.namespace === ns); });
+  entries.push({ key: key, value: value, namespace: ns, storedAt: new Date().toISOString() });
+  saveIndex(entries);
+}
+
+function retrieve(query, namespace) {
+  var entries = loadIndex();
+  var ns = namespace || null;
+  if (ns) entries = entries.filter(function(e) { return e.namespace === ns; });
+  if (!query) return entries.slice(-10);
+  // Simple keyword search
+  var q = String(query).toLowerCase();
+  var scored = entries.map(function(e) {
+    var text = (e.key + ' ' + JSON.stringify(e.value || '')).toLowerCase();
+    var score = 0;
+    var words = q.split(/\s+/);
+    for (var i = 0; i < words.length; i++) {
+      if (words[i] && text.includes(words[i])) score++;
+    }
+    return { entry: e, score: score };
+  });
+  return scored
+    .filter(function(s) { return s.score > 0; })
+    .sort(function(a, b) { return b.score - a.score; })
+    .slice(0, 10)
+    .map(function(s) { return s.entry; });
+}
+
+module.exports = { store, retrieve };

package/.claude/helpers/router.cjs

@@ -0,0 +1,68 @@
+'use strict';
+/**
+ * Keyword-based task router for hook-handler.cjs
+ * Returns: { agent, agentSlug, confidence, reason, semanticRouting, specificAgents, skillMatches, extrasMatches }
+ */
+
+const KEYWORD_ROUTES = [
+  { pattern: /\b(bug|fix|error|exception|crash|broken|fail|regression|null pointer|undefined)\b/i, agent: 'coder', confidence: 0.85 },
+  { pattern: /\b(test|spec|coverage|vitest|jest|mocha|unit test|integration test|e2e)\b/i, agent: 'tester', confidence: 0.85 },
+  { pattern: /\b(review|audit|code quality|lint|smell|refactor|clean up|cleanup)\b/i, agent: 'reviewer', confidence: 0.82 },
+  { pattern: /\b(architect|design|system design|ADR|domain|bounded context|microservice|pattern)\b/i, agent: 'system-architect', confidence: 0.85 },
+  { pattern: /\b(security|vulnerability|CVE|injection|XSS|CSRF|auth|permissions|OWASP)\b/i, agent: 'Security Engineer', confidence: 0.90 },
+  { pattern: /\b(performance|optimiz|slow|bottleneck|profil|benchmark|latency|throughput)\b/i, agent: 'coder', confidence: 0.80 },
+  { pattern: /\b(deploy|CI\/CD|pipeline|docker|kubernetes|infra|devops|helm|terraform)\b/i, agent: 'DevOps Automator', confidence: 0.85 },
+  { pattern: /\b(document|readme|docs|api reference|jsdoc|write up)\b/i, agent: 'Technical Writer', confidence: 0.82 },
+  { pattern: /\b(feature|implement|add|build|create|develop|new)\b/i, agent: 'coder', confidence: 0.75 },
+  { pattern: /\b(research|investigate|explore|analyze|survey|compare)\b/i, agent: 'researcher', confidence: 0.78 },
+  { pattern: /\b(plan|roadmap|strategy|prioritize|breakdown|estimate)\b/i, agent: 'planner', confidence: 0.80 },
+  { pattern: /\b(memory|vector|embedding|HNSW|sqlite|database|query)\b/i, agent: 'coder', confidence: 0.82 },
+  { pattern: /\b(hook|swarm|agent|mcp|cli|routing|monomind)\b/i, agent: 'coder', confidence: 0.80 },
+  { pattern: /\b(mobile|ios|android|react native|flutter)\b/i, agent: 'mobile-dev', confidence: 0.88 },
+  { pattern: /\b(ml|machine learning|AI|model|training|inference|neural)\b/i, agent: 'AI Engineer', confidence: 0.85 },
+  { pattern: /\b(api|rest|graphql|endpoint|http|websocket|grpc)\b/i, agent: 'backend-dev', confidence: 0.80 },
+  { pattern: /\b(ui|frontend|react|vue|component|css|layout|design)\b/i, agent: 'Frontend Developer', confidence: 0.80 },
+];
+
+const DEFAULT_RESULT = {
+  agent: 'coder',
+  agentSlug: 'coder',
+  confidence: 0.60,
+  reason: 'Default routing — no strong keyword match',
+  semanticRouting: false,
+  specificAgents: [],
+  skillMatches: [],
+  extrasMatches: [],
+};
+
+function routeTask(prompt) {
+  if (!prompt || typeof prompt !== 'string') return DEFAULT_RESULT;
+
+  var best = null;
+  for (var i = 0; i < KEYWORD_ROUTES.length; i++) {
+    var rule = KEYWORD_ROUTES[i];
+    if (rule.pattern.test(prompt)) {
+      if (!best || rule.confidence > best.confidence) {
+        best = rule;
+      }
+    }
+  }
+
+  if (!best) return DEFAULT_RESULT;
+
+  return {
+    agent: best.agent,
+    agentSlug: best.agent.toLowerCase().replace(/\s+/g, '-'),
+    confidence: best.confidence,
+    reason: 'Keyword match: ' + best.pattern.toString().slice(1, 40),
+    semanticRouting: false,
+    specificAgents: [],
+    skillMatches: [],
+    extrasMatches: [],
+  };
+}
+
+module.exports = {
+  routeTask: routeTask,
+  routeTaskSemantic: routeTask,
+};

package/.claude/helpers/session.cjs

@@ -0,0 +1,63 @@
+'use strict';
+/**
+ * Session state management for hook-handler.cjs
+ * Persists session data to .monomind/session-state.json
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const SESSION_FILE = path.join(CWD, '.monomind', 'session-state.json');
+
+function ensureDir() {
+  try { fs.mkdirSync(path.dirname(SESSION_FILE), { recursive: true }); } catch (_) {}
+}
+
+function restore() {
+  try {
+    if (!fs.existsSync(SESSION_FILE)) return null;
+    var raw = fs.readFileSync(SESSION_FILE, 'utf-8');
+    var data = JSON.parse(raw);
+    if (!data || !data.sessionId) return null;
+    console.log('[OK] Session restored: ' + data.sessionId);
+    return data;
+  } catch (_) {
+    return null;
+  }
+}
+
+function start() {
+  ensureDir();
+  var sessionId = 'session-' + Date.now();
+  var data = { sessionId: sessionId, startedAt: new Date().toISOString(), editCount: 0, taskCount: 0 };
+  try {
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    console.log('[OK] Session started: ' + sessionId);
+  } catch (_) {}
+  return data;
+}
+
+function update(patch) {
+  ensureDir();
+  try {
+    var existing = restore() || start();
+    var merged = Object.assign({}, existing, patch, { updatedAt: new Date().toISOString() });
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(merged, null, 2), 'utf-8');
+    return merged;
+  } catch (_) {
+    return null;
+  }
+}
+
+function end() {
+  try {
+    var data = restore();
+    if (data) {
+      update({ endedAt: new Date().toISOString() });
+      console.log('[OK] Session ended: ' + data.sessionId);
+    }
+  } catch (_) {}
+}
+
+module.exports = { restore, start, update, end };

package/.claude/helpers/utils/monograph.cjs

@@ -157,13 +157,15 @@ function _injectCompactGraphMap() {
       var recentEdits = _getRecentEdits();
       for (var ri = 0; ri < Math.min(recentEdits.length, 5); ri++) {
         var rfile = recentEdits[ri].file;
-        var rrel = (rfile.indexOf(CWD) === 0) ? rfile.slice(CWD.length + 1) : rfile;
+        // Resolve to absolute for DB lookup (DB stores absolute paths); also keep relative for OR clause
+        var rabs = path.isAbsolute(rfile) ? rfile : path.join(CWD, rfile);
+        var rrel = (rabs.indexOf(CWD) === 0) ? rabs.slice(CWD.length + 1) : rabs;
         try {
           var rnode = db.prepare(
             'SELECT n.name, n.label, n.file_path, ' +
             '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
             'FROM nodes n WHERE n.label=\'File\' AND (n.file_path=? OR n.file_path=?) LIMIT 1'
-          ).get(rfile, rrel);
+          ).get(rabs, rrel);
           if (rnode && !seenPaths[rnode.file_path]) {
             seenPaths[rnode.file_path] = 1;
             anchors.push({ name: rnode.name, label: rnode.label, file_path: rnode.file_path, deg: rnode.deg, tag: '✎' });

package/.claude/helpers/utils/telemetry.cjs

@@ -10,13 +10,14 @@ const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 function _recordRecentEdit(filePath) {
   if (!filePath) return;
   try {
+    var relPath = path.isAbsolute(filePath) ? path.relative(CWD, filePath) : filePath;
     var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
     fs.mkdirSync(path.dirname(f), { recursive: true });
     var d = { edits: [] };
     try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
     if (!Array.isArray(d.edits)) d.edits = [];
-    d.edits = d.edits.filter(function(e) { return e.file !== filePath; });
-    d.edits.unshift({ file: filePath, editedAt: Date.now() });
+    d.edits = d.edits.filter(function(e) { return e.file !== relPath; });
+    d.edits.unshift({ file: relPath, editedAt: Date.now() });
     if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
     fs.writeFileSync(f, JSON.stringify(d));
   } catch (e) { /* non-fatal */ }

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"03297c7b-619d-4277-81a8-5710ba82cb61","pid":6026,"procStart":"Thu Jun  4 08:02:16 2026","acquiredAt":1780700957322}
+{"sessionId":"64f579c5-48a4-4db0-a746-46a7f3fab6ab","pid":6041,"procStart":"Tue Jun  9 11:59:20 2026","acquiredAt":1781035942894}

package/.claude/settings.json

@@ -55,6 +55,16 @@
             "timeout": 4000
           }
         ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs\" pre-write",
+            "timeout": 3000
+          }
+        ]
       }
     ],
     "PostToolUse": [
@@ -229,7 +239,7 @@
   },
   "attribution": {
     "commit": "Co-Authored-By: nokhodian <nokhodian@gmail.com>",
-    "pr": "\ud83e\udd16 Generated with [monomind](https://github.com/nokhodian/monomind)"
+    "pr": "\ud83e\udd16 Generated with [monomind](https://github.com/monoes/monomind)"
   },
   "monomind": {
     "version": "3.5.2",
@@ -345,4 +355,4 @@
   "enabledMcpjsonServers": [
     "monomind"
   ]
-}
+}

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

@@ -625,7 +625,7 @@ async function agentSwarm(taskList) {
 ## Related Documentation
 
 - **NPM Package**: https://npmjs.com/package/agentic-jujutsu
-- **GitHub**: https://github.com/nokhodian/monomind
+- **GitHub**: https://github.com/monoes/monomind
 - **Full README**: See package README.md
 - **Validation Guide**: docs/VALIDATION_FIXES_v2.3.1.md
 - **AgentDB Guide**: docs/AGENTDB_GUIDE.md

package/.claude/skills/hive-mind-advanced/SKILL.md

@@ -696,10 +696,10 @@ npx monomind hive-mind spawn "Review PR #456" \
 
 ## References
 
-- [Hive Mind Documentation](https://github.com/nokhodian/monomind/docs/hive-mind)
-- [Collective Intelligence Patterns](https://github.com/nokhodian/monomind/docs/patterns)
-- [Byzantine Consensus](https://github.com/nokhodian/monomind/docs/consensus)
-- [Memory Optimization](https://github.com/nokhodian/monomind/docs/memory)
+- [Hive Mind Documentation](https://github.com/monoes/monomind/docs/hive-mind)
+- [Collective Intelligence Patterns](https://github.com/monoes/monomind/docs/patterns)
+- [Byzantine Consensus](https://github.com/monoes/monomind/docs/consensus)
+- [Memory Optimization](https://github.com/monoes/monomind/docs/memory)
 
 ---
 

package/.claude/skills/mastermind/_agent-select.md

@@ -25,7 +25,7 @@ REGISTRY="${REGISTRY:-.monomind/registry.json}"
 # 1. Extract candidates from the registry filtered by category
 candidates=$(jq -r \
   --arg cats "$CATEGORIES" \
-  '[ .agents[]
+  '[ (.agents // [])[]
      | select(.deprecated != true)
      | select(
          .category as $c |
@@ -95,7 +95,7 @@ CATS="engineering development"
 best_agent=$(jq -r \
   --arg cats "$CATS" \
   --arg task "$(echo "$TASK_DESC" | tr '[:upper:]' '[:lower:]')" \
-  '[ .agents[]
+  '[ (.agents // [])[]
      | select(.deprecated != true)
      | select(.category as $c | ($cats | split(" ") | any(. == $c)))
      | {name: .name, slug: .slug,

package/.claude/skills/mastermind/access.md

@@ -79,7 +79,7 @@ count=$(jq '.members | length' "$membersFile")
 if [ "$count" -eq 0 ]; then
   echo "  No members. Use --action invite to add the first member."
 else
-  jq -r '.members[] |
+  jq -r '(.members // [])[] |
     [.id, (.role // "viewer"), (.status // "active"),
      ((.grants // []) | join(", ") | if . == "" then "(none)" else . end)]
     | @tsv' "$membersFile" | while IFS=$'\t' read -r id role status grants; do
@@ -88,7 +88,7 @@ else
 fi
 
 # Show pending join requests
-pending=$(jq '[.join_requests[] | select(.status == "pending")] | length' "$membersFile")
+pending=$(jq '[(.join_requests // [])[] | select(.status == "pending")] | length' "$membersFile")
 [ "$pending" -gt 0 ] && echo "" && echo "  ⚠ $pending pending join request(s). Run --action join-requests to review."
 ```
 
@@ -130,7 +130,7 @@ esac
 
 tmp="${membersFile}.tmp"
 jq --arg id "$member_id" --arg role "$role" \
-  '.members = [.members[] | if .id == $id then .role = $role else . end]' \
+  '.members = [(.members // [])[] | if .id == $id then .role = $role else . end]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
 echo "Member '$member_id' role → $role"
 ```
@@ -147,12 +147,12 @@ echo "$validKeys" | grep -qw "$permission" || { echo "ERROR: Unknown permission
 tmp="${membersFile}.tmp"
 if [ "$action" = "grant" ]; then
   jq --arg id "$member_id" --arg perm "$permission" \
-    '.members = [.members[] | if .id == $id then .grants = ((.grants // []) + [$perm] | unique) else . end]' \
+    '.members = [(.members // [])[] | if .id == $id then .grants = ((.grants // []) + [$perm] | unique) else . end]' \
     "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
   echo "Granted: $permission → $member_id"
 else
   jq --arg id "$member_id" --arg perm "$permission" \
-    '.members = [.members[] | if .id == $id then .grants = ((.grants // []) | map(select(. != $perm))) else . end]' \
+    '.members = [(.members // [])[] | if .id == $id then .grants = ((.grants // []) | map(select(. != $perm))) else . end]' \
     "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
   echo "Revoked: $permission from $member_id"
 fi
@@ -163,7 +163,7 @@ fi
 ```bash
 [ -z "$member_id" ] && { echo "ERROR: --member-id required."; exit 1; }
 tmp="${membersFile}.tmp"
-jq --arg id "$member_id" '.members = [.members[] | select(.id != $id)]' \
+jq --arg id "$member_id" '.members = [(.members // [])[] | select(.id != $id)]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
 echo "Removed member: $member_id"
 ```
@@ -174,7 +174,7 @@ echo "Removed member: $member_id"
 [ -z "$member_id" ] && { echo "ERROR: --member-id required."; exit 1; }
 tmp="${membersFile}.tmp"
 jq --arg id "$member_id" \
-  '.members = [.members[] | if .id == $id then .status = "suspended" else . end]' \
+  '.members = [(.members // [])[] | if .id == $id then .status = "suspended" else . end]' \
   "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
 echo "Member '$member_id' suspended. They cannot perform org actions until reinstated."
 ```
@@ -186,7 +186,7 @@ List pending join requests:
 ```bash
 echo "JOIN REQUESTS — org: $org_name"
 echo "────────────────────────────────────────────────────────"
-jq -r '.join_requests[] | select(.status == "pending") |
+jq -r '(.join_requests // [])[] | select(.status == "pending") |
   "[\(.id)] type=\(.type // "join")  role=\(.role // "viewer")  created=\(.createdAt // "?")
    → /mastermind:access --org '"$org_name"' --action approve-join --request-id \(.id)
    → /mastermind:access --org '"$org_name"' --action reject-join  --request-id \(.id)"
@@ -202,15 +202,15 @@ newStatus=$([ "$action" = "approve-join" ] && echo "approved" || echo "rejected"
 tmp="${membersFile}.tmp"
 if [ "$action" = "approve-join" ]; then
   # Get role from request, create member record
-  requestRole=$(jq -r --arg id "$request_id" '.join_requests[] | select(.id == $id) | .role // "viewer"' "$membersFile")
+  requestRole=$(jq -r --arg id "$request_id" '(.join_requests // [])[] | select(.id == $id) | .role // "viewer"' "$membersFile")
   jq --arg id "$request_id" --arg status "$newStatus" --arg role "$requestRole" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    '.join_requests = [.join_requests[] | if .id == $id then .status = $status | .resolvedAt = $ts else . end] |
+    '.join_requests = [(.join_requests // [])[] | if .id == $id then .status = $status | .resolvedAt = $ts else . end] |
      .members += [{"id":$id,"role":$role,"status":"active","grants":[],"joinedAt":$ts}]' \
     "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
   echo "Approved join request $request_id (role: $requestRole). Member added."
 else
   jq --arg id "$request_id" --arg status "$newStatus" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    '.join_requests = [.join_requests[] | if .id == $id then .status = $status | .resolvedAt = $ts else . end]' \
+    '.join_requests = [(.join_requests // [])[] | if .id == $id then .status = $status | .resolvedAt = $ts else . end]' \
     "$membersFile" > "$tmp" && mv "$tmp" "$membersFile"
   echo "Rejected join request $request_id."
 fi

package/.claude/skills/mastermind/adapter-manager.md

@@ -97,7 +97,7 @@ echo "────────────────────────
 printf "%-20s %-22s %-10s %-8s %-8s %s\n" "TYPE" "LABEL" "SOURCE" "MODELS" "STATUS" "VERSION"
 echo "────────────────────────────────────────────────────────"
 
-jq -r '.adapters[] |
+jq -r '(.adapters // [])[] |
   [.type, (.label // .type), (.source // "built-in"),
    ((.modelsCount // 0) | tostring),
    (if .disabled then "disabled" else "enabled" end),
@@ -107,7 +107,7 @@ jq -r '.adapters[] |
 done
 
 total=$(jq '.adapters | length' "$adapterFile")
-enabled=$(jq '[.adapters[] | select(.disabled == false or .disabled == null)] | length' "$adapterFile")
+enabled=$(jq '[(.adapters // [])[] | select(.disabled == false or .disabled == null)] | length' "$adapterFile")
 echo ""
 echo "  Total: $total  |  Enabled: $enabled  |  Disabled: $((total - enabled))"
 echo ""
@@ -119,12 +119,12 @@ echo "  To add a custom HTTP adapter: --action add-http --http-url http://localh
 ```bash
 [ -z "$adapter_type" ] && { echo "ERROR: --adapter-type required."; exit 1; }
 
-exists=$(jq -r --arg t "$adapter_type" '[.adapters[] | select(.type == $t)] | length' "$adapterFile")
+exists=$(jq -r --arg t "$adapter_type" '[(.adapters // [])[] | select(.type == $t)] | length' "$adapterFile")
 [ "$exists" -eq 0 ] && { echo "ERROR: Adapter '$adapter_type' not found. Use --action list to see available adapters."; exit 1; }
 
 tmp="${adapterFile}.tmp"
 jq --arg t "$adapter_type" \
-  '.adapters = [.adapters[] | if .type == $t then .disabled = false else . end]' \
+  '.adapters = [(.adapters // [])[] | if .type == $t then .disabled = false else . end]' \
   "$adapterFile" > "$tmp" && mv "$tmp" "$adapterFile"
 
 echo "Adapter '$adapter_type' ENABLED — will appear in agent model menus."
@@ -135,11 +135,11 @@ echo "Adapter '$adapter_type' ENABLED — will appear in agent model menus."
 ```bash
 [ -z "$adapter_type" ] && { echo "ERROR: --adapter-type required."; exit 1; }
 
-isBuiltIn=$(jq -r --arg t "$adapter_type" '.adapters[] | select(.type == $t) | .isBuiltIn // false' "$adapterFile")
+isBuiltIn=$(jq -r --arg t "$adapter_type" '(.adapters // [])[] | select(.type == $t) | .isBuiltIn // false' "$adapterFile")
 
 tmp="${adapterFile}.tmp"
 jq --arg t "$adapter_type" \
-  '.adapters = [.adapters[] | if .type == $t then .disabled = true else . end]' \
+  '.adapters = [(.adapters // [])[] | if .type == $t then .disabled = true else . end]' \
   "$adapterFile" > "$tmp" && mv "$tmp" "$adapterFile"
 
 echo "Adapter '$adapter_type' DISABLED — hidden from model menus."
@@ -151,7 +151,7 @@ echo "Adapter '$adapter_type' DISABLED — hidden from model menus."
 ```bash
 [ -z "$adapter_type" ] && { echo "ERROR: --adapter-type required."; exit 1; }
 
-pkg=$(jq -r --arg t "$adapter_type" '.adapters[] | select(.type == $t) | .packageName // ""' "$adapterFile")
+pkg=$(jq -r --arg t "$adapter_type" '(.adapters // [])[] | select(.type == $t) | .packageName // ""' "$adapterFile")
 [ -z "$pkg" ] && { echo "ERROR: Adapter '$adapter_type' has no packageName — cannot reinstall. Only npm-installed adapters support reinstall."; exit 1; }
 
 echo "REINSTALL — $adapter_type from $pkg"
@@ -163,7 +163,7 @@ if npm install "$pkg" 2>&1 | tail -5; then
   ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
   tmp="${adapterFile}.tmp"
   jq --arg t "$adapter_type" --arg v "$newVer" --arg ts "$ts" \
-    '.adapters = [.adapters[] | if .type == $t then .version = $v | .reinstalledAt = $ts else . end]' \
+    '.adapters = [(.adapters // [])[] | if .type == $t then .version = $v | .reinstalledAt = $ts else . end]' \
     "$adapterFile" > "$tmp" && mv "$tmp" "$adapterFile"
   echo "  Reinstalled: $adapter_type @ $newVer"
 else
@@ -185,7 +185,7 @@ slug=$(echo "${http_name}" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' |
 slug="http-${slug}"
 
 # Check for duplicate
-dup=$(jq -r --arg t "$slug" '[.adapters[] | select(.type == $t)] | length' "$adapterFile")
+dup=$(jq -r --arg t "$slug" '[(.adapters // [])[] | select(.type == $t)] | length' "$adapterFile")
 [ "$dup" -gt 0 ] && { echo "ERROR: Adapter slug '$slug' already exists. Remove first: --action remove --adapter-type $slug"; exit 1; }
 
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
@@ -209,12 +209,12 @@ echo "  Status:  enabled"
 ```bash
 [ -z "$adapter_type" ] && { echo "ERROR: --adapter-type required."; exit 1; }
 
-isBuiltIn=$(jq -r --arg t "$adapter_type" '.adapters[] | select(.type == $t) | .isBuiltIn // false' "$adapterFile")
+isBuiltIn=$(jq -r --arg t "$adapter_type" '(.adapters // [])[] | select(.type == $t) | .isBuiltIn // false' "$adapterFile")
 [ "$isBuiltIn" = "true" ] && { echo "ERROR: Cannot remove built-in adapter '$adapter_type'. Use --action disable instead."; exit 1; }
 
 tmp="${adapterFile}.tmp"
 jq --arg t "$adapter_type" \
-  '.adapters = [.adapters[] | select(.type != $t)]' \
+  '.adapters = [(.adapters // [])[] | select(.type != $t)]' \
   "$adapterFile" > "$tmp" && mv "$tmp" "$adapterFile"
 
 echo "Adapter '$adapter_type' removed from registry."
@@ -226,7 +226,7 @@ echo "Adapter '$adapter_type' removed from registry."
 echo "CHECKING FOR ADAPTER UPDATES"
 echo "────────────────────────────────────────────────────────"
 
-jq -r '.adapters[] | select(.packageName != null and .packageName != "") |
+jq -r '(.adapters // [])[] | select(.packageName != null and .packageName != "") |
   [.type, .packageName, (.version // "unknown")] | @tsv' \
   "$adapterFile" | while IFS=$'\t' read -r type pkg ver; do
   latest=$(curl -sf "https://registry.npmjs.org/${pkg}/latest" 2>/dev/null | jq -r '.version // "?"' 2>/dev/null || echo "?")
@@ -237,7 +237,7 @@ jq -r '.adapters[] | select(.packageName != null and .packageName != "") |
   fi
 done
 
-npmCount=$(jq '[.adapters[] | select(.packageName != null)] | length' "$adapterFile")
+npmCount=$(jq '[(.adapters // [])[] | select(.packageName != null)] | length' "$adapterFile")
 [ "$npmCount" -eq 0 ] && echo "  No npm-installed adapters to check."
 ```