mcp-nervous-system 1.6.0 → 1.7.1

package/README.md

@@ -4,7 +4,7 @@
 
 7 mechanically enforced rules that prevent the most common failure modes when LLMs have access to real infrastructure: context loss, silent failures, file damage, goal drift, and overreach.
 
-Built by [Arthur Palyan](https://www.levelsofself.com) at Palyan Family AI System. 16 tools including configuration drift detection and emergency kill switch. Battle-tested on an 11-member AI family running 30 processes 24/7 on a single VPS. 58+ violations logged, 0 bypassed.
+Built by [Arthur Palyan](https://www.levelsofself.com) at Palyan Family AI System. 17 tools including configuration drift detection and emergency kill switch. Battle-tested on an 11-member AI family running 30 processes 24/7 on a single VPS. 58+ violations logged, 0 bypassed.
 
 ## The Problem
 
@@ -60,7 +60,7 @@ Protocol: MCP 2024-11-05 (Streamable HTTP + SSE)
 Authentication: None required
 ```
 
-## NEW in v1.5.1
+## NEW in v1.6.0
 
 **drift_audit** (free tier)
 Configuration drift detection across 5 scopes: roles, versions, files, processes, and website. Scans source-of-truth files (family-roles.json, package.json, UNTOUCHABLE_FILES.txt) against all downstream references - HTML pages, JSON configs, markdown docs, and running PM2 processes. Change one file, drift_audit tells you everywhere else that needs updating. The closed loop that keeps your entire system consistent.

package/README.md.bak.1772809790

@@ -0,0 +1,172 @@
+# The Nervous System
+
+**LLM Behavioral Enforcement Framework**
+
+7 mechanically enforced rules that prevent the most common failure modes when LLMs have access to real infrastructure: context loss, silent failures, file damage, goal drift, and overreach.
+
+Built by [Arthur Palyan](https://www.levelsofself.com) at Palyan Family AI System. 16 tools including configuration drift detection and emergency kill switch. Battle-tested on an 11-member AI family running 30 processes 24/7 on a single VPS. 58+ violations logged, 0 bypassed.
+
+## The Problem
+
+When you give an LLM access to your file system, bash, and production infrastructure, it will eventually:
+
+- Edit a file it shouldn't touch
+- Lose context between sessions and start over
+- Drift from the original objective during long tasks
+- Fail silently when a session times out
+- Make logic changes without asking
+- Disappear into debug loops
+
+The Nervous System solves all of these with rules enforced by external mechanisms the LLM cannot override.
+
+## Install
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "nervous-system": {
+      "command": "npx",
+      "args": ["-y", "mcp-nervous-system"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add nervous-system npx mcp-nervous-system
+```
+
+### Direct
+
+```bash
+npx mcp-nervous-system
+```
+
+Server starts on port 3475 with SSE, HTTP, and health endpoints.
+
+### Hosted (No Install)
+
+The server is live and ready to use:
+
+```
+URL: https://api.100levelup.com/mcp-ns/
+Protocol: MCP 2024-11-05 (Streamable HTTP + SSE)
+Authentication: None required
+```
+
+## NEW in v1.5.1
+
+**drift_audit** (free tier)
+Configuration drift detection across 5 scopes: roles, versions, files, processes, and website. Scans source-of-truth files (family-roles.json, package.json, UNTOUCHABLE_FILES.txt) against all downstream references - HTML pages, JSON configs, markdown docs, and running PM2 processes. Change one file, drift_audit tells you everywhere else that needs updating. The closed loop that keeps your entire system consistent.
+
+**Positioning: Auto mode decides what Claude CAN do. The Nervous System governs HOW it behaves while doing it.**
+
+## The 7 Rules
+
+| # | Rule | What It Prevents |
+|---|------|-----------------|
+| 1 | **Dispatch Don't Do** | Debug loops, rabbit holes. Tasks > 2 messages get dispatched. |
+| 2 | **Untouchable** | File damage. Protected files mechanically blocked from editing. |
+| 3 | **Write Progress** | Silent failures. Progress noted before each action. |
+| 4 | **Step Back Every 4** | Goal drift. Forced reflection every 4 messages. |
+| 5 | **Delegate and Return** | Invisible work. Background tasks reported immediately. |
+| 6 | **Ask Before Touching** | Unauthorized changes. Logic changes need human approval. |
+| 7 | **Hand Off** | Context loss. Written handoffs every 3-4 exchanges. |
+
+## MCP Tools (12)
+
+| Tool | Description |
+|------|------------|
+| `get_framework` | Complete framework: all rules, permission protocol, enforcement patterns |
+| `guardrail_rules` | The 7 core rules with triggers, enforcement, and failure modes |
+| `preflight_check` | File protection system: shell script blocks edits to protected files |
+| `session_handoff` | Context preservation: templates for handoff documents |
+| `worklog` | Progress documentation pattern |
+| `violation_logging` | Audit trail: timestamp, type, context for every violation |
+| `step_back_check` | Forced reflection system |
+| `get_nervous_system_info` | System overview and operational stats |
+| `emergency_kill_switch` | Emergency shutdown of all PM2 processes. Requires kill switch secret. Logs to tamper-evident audit trail |
+| `verify_audit_chain` | Walks the SHA-256 hash-chained audit log and verifies every entry. Returns chain integrity status |
+| `dispatch_to_llm` | Spawns a background LLM agent to handle a task. Checks RAM, enforces max 2 concurrent dispatches |
+| `drift_audit` | Configuration drift detection across roles, versions, files, processes, and website. Finds stale values everywhere. |
+
+## Kill Switch
+
+The `emergency_kill_switch` tool provides an emergency shutdown capability. Send a POST request to `/kill` with the kill switch secret to immediately stop all PM2 processes. Every activation is logged to the tamper-evident audit trail with SHA-256 hash chaining, so kill switch events cannot be hidden or altered after the fact.
+
+- Requires authentication (kill switch secret)
+- Logs to hash-chained audit trail
+- Returns confirmation with affected process count
+
+## Tamper-Evident Audit Trail
+
+Every guardrail violation, kill switch activation, and dispatch event is recorded in a SHA-256 hash-chained audit log. Each entry includes the hash of the previous entry, making it cryptographically impossible to alter or delete past records without breaking the chain.
+
+- Use `verify_audit_chain` to walk the entire chain and verify integrity
+- Returns: valid/invalid status, entry count, and break point if tampered
+- 58+ violations logged, 0 bypassed, 0 chain breaks
+
+## Dispatch to LLM
+
+The `dispatch_to_llm` tool enables a brain + agents architecture. Instead of one LLM session doing everything, complex tasks get dispatched to background agents that run independently under the same 7 rules.
+
+- Checks available RAM (requires 500MB+)
+- Enforces max 2 concurrent dispatches
+- Returns PID and log file path for monitoring
+- Every dispatched agent runs under the same nervous system guardrails
+
+## EU AI Act Compliance
+
+The Nervous System provides practical compliance tools for the EU AI Act. See the full compliance page at:
+
+https://api.100levelup.com/family/eu-ai-act.html
+
+## Resources (5)
+
+- `nervous-system://framework` - The complete framework
+- `nervous-system://quick-start` - Quick start guide
+- `nervous-system://rules` - The 7 core rules
+- `nervous-system://templates` - Templates for handoffs, worklogs, preflight
+- `nervous-system://drift-audit` - Configuration drift detection
+
+## Production Stats
+
+From the live Palyan Family AI System deployment (Feb 28 - Mar 5, 2026):
+
+- **58+** violations caught
+- **29** edits blocked by preflight
+- **13** unique files protected
+- **0** rules bypassed
+- **28** processes monitored
+- **7** days continuous operation
+
+## Live Demo
+
+Try it yourself (no login required):
+
+- **[Interactive Demo](https://api.100levelup.com/family/arthur.html?guest=1)** - Talk to a governed LLM and try to break the rules
+- **[Audit Dashboard](https://api.100levelup.com/family/audit.html)** - See real violation history with timeline
+- **[System Status](https://api.100levelup.com/family/status.html)** - Live health checks
+- **[API Documentation](https://api.100levelup.com/family/api-docs.html)** - Full tool and resource reference
+- **[Case Study](https://api.100levelup.com/family/case-study.html)** - Production deployment data
+- **[Plain English Rules](https://api.100levelup.com/family/rules-plain.html)** - For non-technical stakeholders
+- **[Incident Response](https://api.100levelup.com/family/incident-response.html)** - Detection, containment, resolution
+- **[EU AI Act Compliance](https://api.100levelup.com/family/eu-ai-act.html)** - Practical EU AI Act compliance tools
+
+## Philosophy
+
+> "LLMs can't reliably self-enforce promises. Guardrails work via preflight.sh, violation logs, and catching drift. Build enforcement systems, don't make promises."
+
+If a guardrail can be violated by the thing it guards, it is not a guardrail. It is a suggestion.
+
+Every rule in the Nervous System is enforced by an external mechanism: a shell script, a timer, a separate monitoring process. The LLM cannot override, circumvent, or ignore them.
+
+## License
+
+MIT

package/index.js

@@ -715,6 +715,19 @@ const TOOLS = [
         }
       }
     }
+  },
+  // NEW: MCP Analyzer
+  {
+    name: 'mcp_analyzer',
+    annotations: { title: 'MCP Analyzer', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    description: 'Analyzes your project structure and generates a tailored CLAUDE.md with the most useful tools for your workflow. Use mode=analyze to see recommendations, mode=write to generate CLAUDE.md, mode=reload to re-scan and update. Turns the NS from generic tools into a trained assistant that knows your project.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mode: { type: 'string', enum: ['analyze', 'write', 'reload'], description: 'analyze=show recommendations, write=generate CLAUDE.md, reload=re-scan and update CLAUDE.md' },
+        output_path: { type: 'string', description: 'Where to write CLAUDE.md. Defaults to project root.' }
+      }
+    }
   }
 ];
 
@@ -724,7 +737,7 @@ const RESOURCES = [
   { uri: 'nervous-system://quick-start', name: 'Quick Start Guide', description: 'How to implement the nervous system in your own LLM deployment', mimeType: 'text/plain' },
   { uri: 'nervous-system://rules', name: 'The 7 Core Rules', description: 'All 7 behavioral rules with explanations and enforcement', mimeType: 'text/plain' },
   { uri: 'nervous-system://templates', name: 'Templates', description: 'Ready-to-use templates for handoffs, worklogs, preflight, and untouchable lists', mimeType: 'text/plain' },
-  { uri: 'nervous-system://drift-audit', name: 'Drift Audit', description: 'Configuration drift detection - checks roles, versions, file references, and running processes against source-of-truth files', mimeType: 'text/plain' }
+  { uri: 'nervous-system://drift-audit', name: 'Drift Audit', description: 'Configuration drift detection - checks roles, versions, file references, and running processes against source-of-truth files', mimeType: 'text/plain' },
 ];
 
 // ============================================================
@@ -1891,11 +1904,337 @@ function handleToolCall(name, args) {
       return runPrePublishAudit(args.source_file);
     }
 
+    case 'mcp_analyzer': {
+      return runMCPAnalyzer(args.mode, args.output_path);
+    }
+
     default:
       return { error: 'Unknown tool' };
   }
 }
 
+// ============================================================
+// MCP ANALYZER - Analyzes project and generates tailored config
+// ============================================================
+
+function runMCPAnalyzer(mode, outputPath) {
+  const result = {
+    timestamp: new Date().toISOString(),
+    mode: mode || 'analyze',
+    recommended_tools: [],
+    claude_md: null,
+    config_suggestions: null
+  };
+
+  // Step 1: Detect project characteristics
+  const projectRoot = PROJECT.project_root || process.cwd();
+  const characteristics = {
+    has_config: !!PROJECT._source && PROJECT._source !== 'defaults',
+    has_protected_files: false,
+    has_html_pages: false,
+    has_pm2: PROJECT.pm2_managed || false,
+    has_package_json: false,
+    has_git: false,
+    has_tests: false,
+    has_docs: false,
+    has_data_dir: !!PROJECT.data_dir,
+    has_logs_dir: !!PROJECT.logs_dir,
+    file_count: 0,
+    js_files: 0,
+    py_files: 0,
+    html_files: 0,
+    json_files: 0,
+    md_files: 0,
+    project_type: 'unknown',
+    languages: [],
+    frameworks: []
+  };
+
+  // Scan project root
+  try {
+    const scanDir = function(dir, depth) {
+      if (depth > 3) return;
+      try {
+        const items = fs.readdirSync(dir);
+        for (const item of items) {
+          if (item.startsWith('.') || item === 'node_modules' || item === '__pycache__') continue;
+          const fullPath = path.join(dir, item);
+          try {
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+              if (item === 'test' || item === 'tests' || item === '__tests__') characteristics.has_tests = true;
+              if (item === 'docs' || item === 'documentation') characteristics.has_docs = true;
+              if (item === 'public' || item === 'static' || item === 'html') characteristics.has_html_pages = true;
+              scanDir(fullPath, depth + 1);
+            } else {
+              characteristics.file_count++;
+              if (item.endsWith('.js') || item.endsWith('.ts')) characteristics.js_files++;
+              if (item.endsWith('.py')) characteristics.py_files++;
+              if (item.endsWith('.html')) characteristics.html_files++;
+              if (item.endsWith('.json')) characteristics.json_files++;
+              if (item.endsWith('.md')) characteristics.md_files++;
+              if (item === 'package.json') characteristics.has_package_json = true;
+              if (item === '.gitignore' || item === '.git') characteristics.has_git = true;
+              if (item === 'CLAUDE.md' || item === 'claude.md') characteristics.has_docs = true;
+            }
+          } catch (e) {}
+        }
+      } catch (e) {}
+    };
+    scanDir(projectRoot, 0);
+  } catch (e) {}
+
+  // Check for protected files list
+  const protectedPath = projectPath('protected_files_list');
+  if (protectedPath) {
+    try {
+      const content = fs.readFileSync(protectedPath, 'utf8');
+      const lines = content.split('\n').filter(l => l.trim() && !l.trim().startsWith('#'));
+      characteristics.has_protected_files = lines.length > 0;
+      characteristics.protected_count = lines.length;
+    } catch (e) {}
+  }
+
+  // Check for git
+  try {
+    if (fs.existsSync(path.join(projectRoot, '.git'))) characteristics.has_git = true;
+  } catch (e) {}
+
+  // Check for PM2
+  if (!characteristics.has_pm2) {
+    try {
+      const { execSync } = require('child_process');
+      execSync('pm2 jlist 2>/dev/null', { timeout: 5000 });
+      characteristics.has_pm2 = true;
+    } catch (e) {}
+  }
+
+  // Determine project type
+  if (characteristics.js_files > 0) characteristics.languages.push('javascript');
+  if (characteristics.py_files > 0) characteristics.languages.push('python');
+
+  if (characteristics.has_pm2 && characteristics.js_files > 5) {
+    characteristics.project_type = 'production_system';
+  } else if (characteristics.has_html_pages && characteristics.js_files > 0) {
+    characteristics.project_type = 'web_application';
+  } else if (characteristics.has_package_json && characteristics.js_files > 0) {
+    characteristics.project_type = 'node_project';
+  } else if (characteristics.py_files > 0) {
+    characteristics.project_type = 'python_project';
+  } else if (characteristics.md_files > 2) {
+    characteristics.project_type = 'documentation';
+  } else {
+    characteristics.project_type = 'general';
+  }
+
+  // Don't expose raw project internals - just use them for recommendations
+  result.project_type = characteristics.project_type;
+  result.has_config = characteristics.has_config;
+
+  // Step 2: Recommend tools based on project type
+  const recommendations = [];
+
+  // Universal tools everyone needs
+  recommendations.push({
+    tool: 'get_framework',
+    priority: 'essential',
+    reason: 'Core behavioral rules. Read this first to understand how the NS works.'
+  });
+  recommendations.push({
+    tool: 'preflight_check',
+    priority: 'essential',
+    reason: 'Protects critical files from accidental edits. Set up your protected files list.'
+  });
+  recommendations.push({
+    tool: 'worklog',
+    priority: 'essential',
+    reason: 'Prevents silent failures. Write progress before every action.'
+  });
+  recommendations.push({
+    tool: 'session_handoff',
+    priority: 'essential',
+    reason: 'Solves context loss between sessions. Update the handoff before ending work.'
+  });
+
+  // Conditional tools
+  if (characteristics.has_protected_files || characteristics.file_count > 20) {
+    recommendations.push({
+      tool: 'guardrail_rules',
+      priority: 'high',
+      reason: 'Protected files detected. These rules enforce discipline around file edits.'
+    });
+  }
+
+  if (characteristics.project_type === 'production_system') {
+    recommendations.push({
+      tool: 'drift_audit',
+      priority: 'high',
+      reason: 'Production system detected. Drift audit catches when configs, docs, and running processes go out of sync.'
+    });
+    recommendations.push({
+      tool: 'security_audit',
+      priority: 'high',
+      reason: 'Production system detected. Security audit catches exposed secrets and misconfigurations.'
+    });
+    recommendations.push({
+      tool: 'emergency_kill_switch',
+      priority: 'medium',
+      reason: 'Production system with PM2. Kill switch gives you emergency shutdown capability.'
+    });
+    recommendations.push({
+      tool: 'dispatch_to_llm',
+      priority: 'high',
+      reason: 'Complex system. Dispatch heavy tasks to background agents instead of blocking your main session.'
+    });
+  }
+
+  if (characteristics.has_pm2) {
+    recommendations.push({
+      tool: 'session_close',
+      priority: 'high',
+      reason: 'PM2 processes detected. Session close runs full audit + propagation before you end work.'
+    });
+  }
+
+  if (characteristics.has_html_pages) {
+    recommendations.push({
+      tool: 'page_health',
+      priority: 'medium',
+      reason: 'HTML pages detected. Page health catches broken links, missing meta tags, and UX issues.'
+    });
+  }
+
+  if (characteristics.has_package_json && characteristics.has_git) {
+    recommendations.push({
+      tool: 'pre_publish_audit',
+      priority: 'high',
+      reason: 'Publishable package detected. Pre-publish audit catches secrets and hardcoded paths before they ship.'
+    });
+  }
+
+  recommendations.push({
+    tool: 'step_back_check',
+    priority: 'medium',
+    reason: 'Forces reflection every few messages. Prevents tunnel vision on details.'
+  });
+
+  recommendations.push({
+    tool: 'verify_audit_chain',
+    priority: 'low',
+    reason: 'Tamper-proof audit trail. Verifies no one has modified the activity log.'
+  });
+
+  // Sort by priority
+  const priorityOrder = { essential: 0, high: 1, medium: 2, low: 3 };
+  recommendations.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+
+  result.recommended_tools = recommendations;
+
+  // Step 3: Generate CLAUDE.md
+  const essentialTools = recommendations.filter(r => r.priority === 'essential').map(r => r.tool);
+  const highTools = recommendations.filter(r => r.priority === 'high').map(r => r.tool);
+  const mediumTools = recommendations.filter(r => r.priority === 'medium').map(r => r.tool);
+
+  let claudeMd = '# CLAUDE.md - Generated by The Nervous System MCP Analyzer\n';
+  claudeMd += '# Project type: ' + characteristics.project_type + '\n';
+  claudeMd += '# Generated: ' + result.timestamp + '\n';
+  claudeMd += '# Re-run: mcp_analyzer mode=reload to refresh\n\n';
+
+  claudeMd += '## BEHAVIORAL RULES\n\n';
+  claudeMd += 'This project uses The Nervous System for LLM behavioral enforcement.\n';
+  claudeMd += 'Before doing anything, internalize these rules:\n\n';
+  claudeMd += '1. DISPATCH DONT DO - If a task takes 2+ messages, write a task file and dispatch it.\n';
+  claudeMd += '2. UNTOUCHABLE = UNTOUCHABLE - Run preflight before ANY file edit. If blocked, STOP.\n';
+  claudeMd += '3. WRITE PROGRESS AS YOU GO - Note what you are about to do before each action.\n';
+  claudeMd += '4. STEP BACK EVERY 4 MESSAGES - Are we solving the real problem?\n';
+  claudeMd += '5. ASK BEFORE TOUCHING - Do not modify configs or processes without permission.\n';
+  claudeMd += '6. HAND OFF EVERY FEW MESSAGES - Update the session handoff file.\n\n';
+
+  if (characteristics.has_protected_files) {
+    claudeMd += '## PROTECTED FILES\n\n';
+    claudeMd += 'This project has a protected files list at: ' + (protectedPath || 'PROTECTED_FILES.txt') + '\n';
+    claudeMd += 'Run preflight_check before editing ANY file. If it is protected, STOP and ask.\n\n';
+  }
+
+  claudeMd += '## YOUR TOOLS (in order of importance)\n\n';
+  claudeMd += '### Always use these:\n';
+  for (const t of essentialTools) {
+    const rec = recommendations.find(r => r.tool === t);
+    claudeMd += '- **' + t + '** - ' + rec.reason + '\n';
+  }
+
+  if (highTools.length > 0) {
+    claudeMd += '\n### Use regularly:\n';
+    for (const t of highTools) {
+      const rec = recommendations.find(r => r.tool === t);
+      claudeMd += '- **' + t + '** - ' + rec.reason + '\n';
+    }
+  }
+
+  if (mediumTools.length > 0) {
+    claudeMd += '\n### Use when relevant:\n';
+    for (const t of mediumTools) {
+      const rec = recommendations.find(r => r.tool === t);
+      claudeMd += '- **' + t + '** - ' + rec.reason + '\n';
+    }
+  }
+
+  claudeMd += '\n## SESSION WORKFLOW\n\n';
+  claudeMd += '1. Start: Read session handoff file to see where the last session left off\n';
+  claudeMd += '2. Work: Write progress before each action. Run preflight before file edits.\n';
+  if (characteristics.has_pm2) {
+    claudeMd += '3. End: Call session_close (runs drift audit + propagators automatically)\n';
+  } else {
+    claudeMd += '3. End: Update the session handoff file with what was done and what is next\n';
+  }
+  claudeMd += '4. Every 4 messages: Call step_back_check to verify direction\n\n';
+
+  if (characteristics.project_type === 'production_system') {
+    claudeMd += '## PRODUCTION RULES\n\n';
+    claudeMd += 'This is a production system. Extra care required:\n';
+    claudeMd += '- Run security_audit after any auth or config changes\n';
+    claudeMd += '- Run drift_audit after any file changes\n';
+    claudeMd += '- Run pre_publish_audit before publishing any packages\n';
+    claudeMd += '- Use dispatch_to_llm for tasks that take 2+ messages\n';
+    claudeMd += '- Kill switch is available for emergencies\n\n';
+  }
+
+  // Only include CLAUDE.md content in write/reload mode, not analyze
+  if (mode === 'write' || mode === 'reload') {
+    result.claude_md_generated = true;
+  }
+
+  // Step 4: Config suggestions (if no config exists)
+  if (!characteristics.has_config) {
+    result.setup_needed = true;
+    result.setup_message = 'No nervous-system.config.json found. Run with mode=write to create one and generate a tailored CLAUDE.md for your project.';
+  } else {
+    result.setup_needed = false;
+  }
+
+  // Step 5: If mode is 'reload' or 'write', write the CLAUDE.md
+  if ((mode === 'reload' || mode === 'write') && outputPath) {
+    try {
+      fs.writeFileSync(outputPath, claudeMd);
+      result.written_to = outputPath;
+    } catch (e) {
+      result.write_error = e.message;
+    }
+  } else if (mode === 'reload' || mode === 'write') {
+    // Default output path
+    const defaultPath = path.join(projectRoot, 'CLAUDE.md');
+    try {
+      fs.writeFileSync(defaultPath, claudeMd);
+      result.written_to = defaultPath;
+    } catch (e) {
+      result.write_error = e.message;
+    }
+  }
+
+  return result;
+}
+
+
 // Handle resource reads
 function handleResourceRead(uri) {
   switch (uri) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-nervous-system",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "The Nervous System - LLM Behavioral Enforcement Framework. 7 mechanically enforced rules, 17 tools including kill switch, audit chain, dispatch, drift audit, security audit, page health, pre-publish audit, and session close. MCP server for Claude Desktop, Claude Code, and any MCP-compatible client.",
   "main": "server.js",
   "bin": {

package/package.json.bak.1772809772

@@ -0,0 +1,42 @@
+{
+  "name": "mcp-nervous-system",
+  "version": "1.6.0",
+  "description": "The Nervous System - LLM Behavioral Enforcement Framework. 7 mechanically enforced rules, 17 tools including kill switch, audit chain, dispatch, drift audit, security audit, page health, pre-publish audit, and session close. MCP server for Claude Desktop, Claude Code, and any MCP-compatible client.",
+  "main": "server.js",
+  "bin": {
+    "mcp-nervous-system": "./stdio.js"
+  },
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "llm",
+    "ai-safety",
+    "ai-governance",
+    "behavioral-enforcement",
+    "guardrails",
+    "claude",
+    "anthropic",
+    "nervous-system",
+    "kill-switch",
+    "audit-trail"
+  ],
+  "author": "Arthur Palyan <palyanai@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/levelsofself/mcp-nervous-system"
+  },
+  "homepage": "https://api.100levelup.com/family/gateway.html",
+  "bugs": {
+    "url": "https://github.com/levelsofself/mcp-nervous-system/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/smoke-test.js

@@ -0,0 +1,484 @@
+#!/usr/bin/env node
+// NS Smoke Test - Regression testing for The Nervous System MCP Server
+// Run after every restart, before every publish, and daily via Tamara
+// Usage: node ns-smoke-test.js [port] [--pre-publish] [--verbose]
+
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+const { execSync, spawn } = require('child_process');
+
+const args = process.argv.slice(2);
+const PORT = parseInt(args.find(a => /^\d+$/.test(a))) || 3475;
+const PRE_PUBLISH = args.includes('--pre-publish');
+const VERBOSE = args.includes('--verbose');
+const FRESH_INSTALL = args.includes('--fresh-install');
+
+// All 16 tools with minimal valid arguments
+const TOOL_TESTS = [
+  { name: 'get_framework', args: {}, expectFields: ['name', 'version', 'core_rules'] },
+  { name: 'get_nervous_system_info', args: { topic: 'overview' }, expectType: 'string' },
+  { name: 'guardrail_rules', args: { rule: 'all' }, expectType: 'object' },
+  { name: 'step_back_check', args: { context: 'smoke test' }, expectFields: ['trigger', 'steps'] },
+  { name: 'preflight_check', args: { action: 'get_script' }, expectType: 'string' },
+  { name: 'violation_logging', args: { action: 'get_pattern' }, expectType: 'string' },
+  { name: 'worklog', args: { action: 'get_template' }, expectType: 'string' },
+  { name: 'session_handoff', args: { action: 'get_template' }, expectType: 'string' },
+  { name: 'drift_audit', args: { scope: 'roles' }, expectFields: ['status', 'drift_count'] },
+  { name: 'security_audit', args: {}, expectFields: ['status'] },
+  { name: 'page_health', args: { page: 'all' }, expectType: 'object' },
+  { name: 'verify_audit_chain', args: {}, expectType: 'object' },
+  { name: 'auto_propagate', args: {}, expectType: 'object' },
+  { name: 'session_close', args: {}, expectType: 'object' },
+  // dispatch_to_llm - skip in smoke test (spawns real agent)
+  // emergency_kill_switch - skip in smoke test (stops everything)
+];
+
+// Tools that should NOT be called in smoke tests
+const SKIP_TOOLS = ['dispatch_to_llm', 'emergency_kill_switch'];
+
+let passed = 0;
+let failed = 0;
+let skipped = 0;
+const failures = [];
+
+function log(msg) { console.log(msg); }
+function vlog(msg) { if (VERBOSE) console.log('  ' + msg); }
+
+function callMCP(method, params) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: method,
+      params: params || {}
+    });
+
+    const req = http.request({
+      hostname: 'localhost',
+      port: PORT,
+      path: '/mcp',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      timeout: 15000
+    }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error('Invalid JSON response: ' + data.substring(0, 200)));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function testHealth() {
+  log('\n[1/5] HEALTH CHECK');
+  try {
+    const resp = await new Promise((resolve, reject) => {
+      const req = http.get({ hostname: 'localhost', port: PORT, path: '/health', timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+          catch (e) { resolve({ status: res.statusCode, body: data }); }
+        });
+      });
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    });
+
+    if (resp.status === 200) {
+      passed++;
+      log('  PASS: /health returns 200');
+      vlog('Response: ' + JSON.stringify(resp.body));
+    } else {
+      failed++;
+      failures.push({ test: 'health', error: 'Status ' + resp.status });
+      log('  FAIL: /health returns ' + resp.status);
+    }
+  } catch (e) {
+    failed++;
+    failures.push({ test: 'health', error: e.message });
+    log('  FAIL: /health - ' + e.message);
+  }
+}
+
+async function testInitialize() {
+  log('\n[2/5] MCP INITIALIZE');
+  try {
+    const resp = await callMCP('initialize', {});
+    if (resp.result && resp.result.serverInfo && resp.result.capabilities) {
+      passed++;
+      log('  PASS: initialize returns valid server info');
+      vlog('Server: ' + resp.result.serverInfo.name + ' v' + resp.result.serverInfo.version);
+      vlog('Capabilities: ' + Object.keys(resp.result.capabilities).join(', '));
+    } else {
+      failed++;
+      failures.push({ test: 'initialize', error: 'Missing serverInfo or capabilities' });
+      log('  FAIL: initialize - bad response structure');
+    }
+  } catch (e) {
+    failed++;
+    failures.push({ test: 'initialize', error: e.message });
+    log('  FAIL: initialize - ' + e.message);
+  }
+}
+
+async function testToolsList() {
+  log('\n[3/5] TOOLS LIST');
+  try {
+    const resp = await callMCP('tools/list', {});
+    if (resp.result && resp.result.tools && Array.isArray(resp.result.tools)) {
+      const toolNames = resp.result.tools.map(t => t.name);
+      passed++;
+      log('  PASS: tools/list returns ' + toolNames.length + ' tools');
+      vlog('Tools: ' + toolNames.join(', '));
+
+      // Verify expected tools exist
+      const expectedTools = TOOL_TESTS.map(t => t.name).concat(SKIP_TOOLS);
+      const missing = expectedTools.filter(t => !toolNames.includes(t));
+      if (missing.length > 0) {
+        failed++;
+        failures.push({ test: 'tools_list_completeness', error: 'Missing tools: ' + missing.join(', ') });
+        log('  FAIL: Missing expected tools: ' + missing.join(', '));
+      } else {
+        passed++;
+        log('  PASS: All expected tools present');
+      }
+    } else {
+      failed++;
+      failures.push({ test: 'tools_list', error: 'Invalid response' });
+      log('  FAIL: tools/list - invalid response');
+    }
+  } catch (e) {
+    failed++;
+    failures.push({ test: 'tools_list', error: e.message });
+    log('  FAIL: tools/list - ' + e.message);
+  }
+}
+
+async function testEachTool() {
+  log('\n[4/5] INDIVIDUAL TOOL CALLS');
+  for (const test of TOOL_TESTS) {
+    try {
+      const resp = await callMCP('tools/call', { name: test.name, arguments: test.args });
+
+      // Check for rate limit (not a real failure)
+      if (resp.result && resp.result.content && resp.result.content[0] &&
+          resp.result.content[0].text && (resp.result.content[0].text.includes('rate_limit') || resp.result.content[0].text.includes('authentication_required'))) {
+        skipped++;
+        log('  SKIP: ' + test.name + ' (rate limited)');
+        continue;
+      }
+
+      // Check for valid response
+      if (resp.error) {
+        failed++;
+        failures.push({ test: test.name, error: resp.error.message || JSON.stringify(resp.error) });
+        log('  FAIL: ' + test.name + ' - ' + (resp.error.message || 'error'));
+        continue;
+      }
+
+      if (!resp.result || !resp.result.content || !resp.result.content[0]) {
+        failed++;
+        failures.push({ test: test.name, error: 'Empty or invalid response structure' });
+        log('  FAIL: ' + test.name + ' - empty response');
+        continue;
+      }
+
+      const text = resp.result.content[0].text;
+      let parsed;
+      try { parsed = JSON.parse(text); } catch (e) { parsed = text; }
+
+      // Validate expected shape
+      if (test.expectFields) {
+        const missingFields = test.expectFields.filter(f => !(f in parsed));
+        if (missingFields.length > 0) {
+          failed++;
+          failures.push({ test: test.name, error: 'Missing fields: ' + missingFields.join(', ') });
+          log('  FAIL: ' + test.name + ' - missing fields: ' + missingFields.join(', '));
+        } else {
+          passed++;
+          log('  PASS: ' + test.name);
+          vlog('Fields present: ' + test.expectFields.join(', '));
+        }
+      } else if (test.expectType === 'string') {
+        if (typeof parsed === 'string' && parsed.length > 0) {
+          passed++;
+          log('  PASS: ' + test.name + ' (' + parsed.length + ' chars)');
+        } else if (typeof parsed === 'object') {
+          // Some tools return JSON even when we expect string, that is fine
+          passed++;
+          log('  PASS: ' + test.name + ' (object response)');
+        } else {
+          failed++;
+          failures.push({ test: test.name, error: 'Expected string, got ' + typeof parsed });
+          log('  FAIL: ' + test.name + ' - expected string');
+        }
+      } else if (test.expectType === 'object') {
+        if (typeof parsed === 'object' && parsed !== null) {
+          passed++;
+          log('  PASS: ' + test.name);
+        } else {
+          failed++;
+          failures.push({ test: test.name, error: 'Expected object, got ' + typeof parsed });
+          log('  FAIL: ' + test.name + ' - expected object');
+        }
+      } else {
+        passed++;
+        log('  PASS: ' + test.name + ' (response received)');
+      }
+
+    } catch (e) {
+      failed++;
+      failures.push({ test: test.name, error: e.message });
+      log('  FAIL: ' + test.name + ' - ' + e.message);
+    }
+  }
+
+  // Note skipped dangerous tools
+  for (const skip of SKIP_TOOLS) {
+    skipped++;
+    log('  SKIP: ' + skip + ' (dangerous in test)');
+  }
+}
+
+async function testSourceCode() {
+  log('\n[5/5] SOURCE CODE CHECKS');
+
+  // Find the NS source file
+  const candidates = [
+    path.join(__dirname, 'index.js'),
+    '/root/mcp-nervous-system.js',
+    path.join(process.cwd(), 'index.js'),
+  ];
+  let sourceFile = null;
+  for (const c of candidates) {
+    if (fs.existsSync(c)) { sourceFile = c; break; }
+  }
+
+  if (!sourceFile) {
+    skipped++;
+    log('  SKIP: Could not find NS source file');
+    return;
+  }
+
+  const content = fs.readFileSync(sourceFile, 'utf8');
+
+  // Check for leaked passwords (common patterns)
+  const passwordPatterns = [
+    /Liarzhek/i,
+    /Levelsofself1/i,
+  ];
+  let passwordClean = true;
+  for (const pat of passwordPatterns) {
+    if (pat.test(content)) {
+      failed++;
+      passwordClean = false;
+      failures.push({ test: 'password_check', error: 'Password pattern found: ' + pat.source });
+      log('  FAIL: Password found in source: ' + pat.source);
+    }
+  }
+  if (passwordClean) {
+    passed++;
+    log('  PASS: No known passwords in source');
+  }
+
+  // Check for hardcoded paths (only in non-description/non-comment lines)
+  if (PRE_PUBLISH) {
+    const lines = content.split('\n');
+    let hardcodedPaths = 0;
+    lines.forEach((line, idx) => {
+      if (line.trim().startsWith('//')) return;
+      if (line.includes('description:') || line.includes('context:') || line.includes('tagline:')) return;
+      if (line.includes("'/root/") || line.includes('"/root/')) {
+        hardcodedPaths++;
+        vlog('Line ' + (idx + 1) + ': ' + line.trim().substring(0, 80));
+      }
+    });
+    if (hardcodedPaths > 0) {
+      // Warning not failure -- v1.5.2 still has these, v1.6.0 will fix
+      log('  WARN: ' + hardcodedPaths + ' hardcoded /root/ paths (fix in v1.6.0)');
+    } else {
+      passed++;
+      log('  PASS: No hardcoded /root/ paths');
+    }
+  }
+
+  // Syntax check
+  try {
+    execSync('node -c ' + sourceFile + ' 2>&1');
+    passed++;
+    log('  PASS: Syntax check (node -c)');
+  } catch (e) {
+    failed++;
+    failures.push({ test: 'syntax_check', error: 'Syntax error in ' + sourceFile });
+    log('  FAIL: Syntax error in source');
+  }
+}
+
+async function testFreshInstall() {
+  log('\n[BONUS] FRESH INSTALL TEST');
+  const tmpDir = '/tmp/ns-fresh-test-' + Date.now();
+
+  try {
+    // Create temp directory and install from npm
+    fs.mkdirSync(tmpDir, { recursive: true });
+    log('  Installing mcp-nervous-system in ' + tmpDir + '...');
+    execSync('cd ' + tmpDir + ' && npm init -y > /dev/null 2>&1 && npm install mcp-nervous-system > /dev/null 2>&1', { timeout: 60000 });
+
+    // Find the installed index.js
+    const indexPath = path.join(tmpDir, 'node_modules', 'mcp-nervous-system', 'index.js');
+    if (!fs.existsSync(indexPath)) {
+      failed++;
+      failures.push({ test: 'fresh_install', error: 'index.js not found after npm install' });
+      log('  FAIL: index.js not found');
+      return;
+    }
+
+    // Syntax check the installed file
+    try {
+      execSync('node -c ' + indexPath + ' 2>&1');
+      passed++;
+      log('  PASS: Fresh install syntax check');
+    } catch (e) {
+      failed++;
+      failures.push({ test: 'fresh_install_syntax', error: 'Syntax error in fresh install' });
+      log('  FAIL: Fresh install has syntax error');
+    }
+
+    // Check for passwords in installed file
+    const content = fs.readFileSync(indexPath, 'utf8');
+    if (/Liarzhek|Levelsofself1/i.test(content)) {
+      failed++;
+      failures.push({ test: 'fresh_install_passwords', error: 'Passwords still in npm package' });
+      log('  FAIL: Passwords found in fresh npm install!');
+    } else {
+      passed++;
+      log('  PASS: No passwords in fresh npm install');
+    }
+
+    // Start the server on a random port and test health
+    const testPort = 19475 + Math.floor(Math.random() * 1000);
+    const stdioPth = path.join(tmpDir, 'node_modules', 'mcp-nervous-system', 'server.js');
+    if (fs.existsSync(stdioPth)) {
+      // Patch port for testing
+      const serverContent = fs.readFileSync(stdioPth, 'utf8');
+      const patchedContent = serverContent.replace(/const PORT = \d+/, 'const PORT = ' + testPort);
+      const patchedPath = path.join(tmpDir, 'test-server.js');
+      fs.writeFileSync(patchedPath, patchedContent);
+
+      const proc = spawn('node', [patchedPath], {
+        cwd: tmpDir,
+        stdio: 'ignore',
+        detached: true,
+        env: { ...process.env, PORT: testPort.toString() }
+      });
+
+      // Wait for startup
+      await new Promise(r => setTimeout(r, 3000));
+
+      try {
+        const healthResp = await new Promise((resolve, reject) => {
+          const req = http.get({ hostname: 'localhost', port: testPort, path: '/health', timeout: 5000 }, (res) => {
+            let data = '';
+            res.on('data', c => data += c);
+            res.on('end', () => resolve({ status: res.statusCode }));
+          });
+          req.on('error', reject);
+          req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+        });
+
+        if (healthResp.status === 200) {
+          passed++;
+          log('  PASS: Fresh install server starts and responds on port ' + testPort);
+        } else {
+          failed++;
+          log('  FAIL: Fresh install server returned status ' + healthResp.status);
+        }
+      } catch (e) {
+        // Server might not start without dependencies - that is OK to note
+        skipped++;
+        log('  SKIP: Fresh install server could not start (' + e.message + ')');
+      }
+
+      // Cleanup
+      try { process.kill(-proc.pid); } catch (e) {}
+    }
+
+  } catch (e) {
+    failed++;
+    failures.push({ test: 'fresh_install', error: e.message });
+    log('  FAIL: Fresh install test - ' + e.message);
+  } finally {
+    // Cleanup
+    try { execSync('rm -rf ' + tmpDir + ' 2>/dev/null'); } catch (e) {}
+  }
+}
+
+async function run() {
+  log('===========================================');
+  log('  NERVOUS SYSTEM SMOKE TEST');
+  log('  Port: ' + PORT);
+  log('  Mode: ' + (PRE_PUBLISH ? 'PRE-PUBLISH' : FRESH_INSTALL ? 'FRESH INSTALL' : 'STANDARD'));
+  log('  Time: ' + new Date().toISOString());
+  log('===========================================');
+
+  await testHealth();
+  await testInitialize();
+  await testToolsList();
+  await testEachTool();
+  await testSourceCode();
+
+  if (FRESH_INSTALL || PRE_PUBLISH) {
+    await testFreshInstall();
+  }
+
+  log('\n===========================================');
+  log('  RESULTS');
+  log('===========================================');
+  log('  Passed:  ' + passed);
+  log('  Failed:  ' + failed);
+  log('  Skipped: ' + skipped);
+  log('  Total:   ' + (passed + failed + skipped));
+
+  if (failures.length > 0) {
+    log('\n  FAILURES:');
+    failures.forEach(f => log('    - ' + f.test + ': ' + f.error));
+  }
+
+  const status = failed === 0 ? 'ALL PASS' : 'FAILURES DETECTED';
+  log('\n  STATUS: ' + status);
+  log('===========================================');
+
+  // Write results to log file for Tamara
+  const resultFile = '/tmp/ns-smoke-test-result.json';
+  const result = {
+    timestamp: new Date().toISOString(),
+    port: PORT,
+    mode: PRE_PUBLISH ? 'pre-publish' : FRESH_INSTALL ? 'fresh-install' : 'standard',
+    passed: passed,
+    failed: failed,
+    skipped: skipped,
+    status: status,
+    failures: failures
+  };
+  try {
+    fs.writeFileSync(resultFile, JSON.stringify(result, null, 2));
+  } catch (e) {}
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+run().catch(e => {
+  console.error('Smoke test crashed: ' + e.message);
+  process.exit(2);
+});