ruvector 0.2.31 → 0.2.32

package/README.md

@@ -91,6 +91,38 @@ claude mcp add ruvector -- npx ruvector mcp start
 - `midstream_status`, `midstream_attractor`, `midstream_scheduler` — Streaming analysis
 - `midstream_benchmark`, `midstream_search`, `midstream_health` — Latency benchmarks + health
 
+**MCP tool-access policy (default-deny, ADR-256):** restrict the exposed/callable
+tool surface with environment variables — useful for least-privilege deployments.
+
+```bash
+# Only expose specific tools (everything else is denied)
+RUVECTOR_MCP_ALLOW="hooks_route,hooks_recall" npx ruvector mcp start
+
+# Block specific tools (deny wins over allow)
+RUVECTOR_MCP_DENY="hooks_force_learn" npx ruvector mcp start
+
+# Apply a curated read-only profile (safe, non-mutating subset)
+RUVECTOR_MCP_PROFILE=readonly npx ruvector mcp start
+```
+
+Precedence is **DENY > ALLOW/PROFILE > allow-all**. With no policy set, all tools
+are available (backward compatible). Inspect the active posture with
+`npx ruvector harness status --json` (see `mcp.accessControl`).
+
+### Harness Router (ADR-256)
+
+`ruvector harness` surfaces the unified routing/agentic primitives ruvector ships —
+cost-optimal model routing (Tiny Dancer), semantic routing, hooks routing, the MCP
+server, witness-signed provenance, and SONA memory — in one place:
+
+```bash
+npx ruvector harness status          # human-readable surface + availability
+npx ruvector harness status --json   # structured, for tooling/CI
+```
+
+Memory + learning loops use a stable namespace (default `ruvector`), overridable per
+deployment with `RUVECTOR_MEMORY_NAMESPACE` and reported under `memory.namespace`.
+
 ### Brain AGI Commands
 
 Access all 8 AGI subsystems deployed at π.ruv.io:

package/bin/cli.js

@@ -10101,6 +10101,137 @@ const optimizeCmd = program.command('optimize')
     console.log('');
   });
 
+// =============================================================================
+// Harness Commands - unified "harness router" surface (ADR-256)
+// Borrows metaharness concepts using primitives ruvector already ships:
+//   cost router (tiny-dancer) + semantic router + hooks routing + MCP + witness
+// Read-only status surface; degrades gracefully when optional deps are absent.
+// =============================================================================
+
+function buildHarnessSurface() {
+  const primitives = {};
+
+  // Cost-optimal model router — Tiny Dancer FastGRNN (ADR-252)
+  try {
+    const td = require('@ruvector/tiny-dancer');
+    primitives.costRouter = {
+      name: '@ruvector/tiny-dancer',
+      role: 'cost-optimal model routing (cheap vs strong)',
+      available: true,
+      version: typeof td.version === 'function' ? td.version() : null,
+      usage: 'npx ruvector tiny-dancer score <model> --query <embedding>',
+    };
+  } catch {
+    primitives.costRouter = {
+      name: '@ruvector/tiny-dancer',
+      role: 'cost-optimal model routing (cheap vs strong)',
+      available: false,
+      install: 'npm install @ruvector/tiny-dancer',
+    };
+  }
+
+  // Semantic intent router — @ruvector/router / ruvector-router-core
+  let semanticAvailable = false;
+  try { require.resolve('@ruvector/router'); semanticAvailable = true; } catch { semanticAvailable = false; }
+  primitives.semanticRouter = {
+    name: '@ruvector/router',
+    role: 'semantic intent routing',
+    available: semanticAvailable,
+    ...(semanticAvailable ? { usage: 'npx ruvector router --route "<text>"' } : { install: 'npm install @ruvector/router' }),
+  };
+
+  // Multi-tier intelligence routing — bundled (ADR-026)
+  primitives.hooksRouting = {
+    name: 'hooks route',
+    role: '3-tier task→agent/model routing (ADR-026)',
+    available: true,
+    usage: 'npx ruvector hooks route "<task>"',
+  };
+
+  // Agentic tool surface — bundled MCP server (with ADR-256 default-deny policy)
+  const mcpPath = path.join(__dirname, 'mcp-server.js');
+  let mcpPolicy = { configured: false };
+  try {
+    const { buildToolPolicy } = require('./mcp-policy.js');
+    const p = buildToolPolicy(process.env);
+    mcpPolicy = {
+      configured: p.configured,
+      profile: p.profile || null,
+      allow: p.allowSet ? p.allowSet.size : 0,
+      deny: p.deny.size,
+    };
+  } catch { /* policy module optional */ }
+  primitives.mcp = {
+    name: 'mcp-server',
+    role: 'agentic tool surface (Model Context Protocol)',
+    available: fs.existsSync(mcpPath),
+    usage: 'npx ruvector mcp start',
+    policy: mcpPolicy,
+    accessControl: mcpPolicy.configured ? 'default-deny (configured)' : 'allow-all (set RUVECTOR_MCP_ALLOW/PROFILE)',
+  };
+
+  // Signed provenance — witness chain (ADR-103 / ADR-134)
+  primitives.witness = {
+    name: 'witness-chain',
+    role: 'signed provenance / release signing (ADR-103, ADR-134)',
+    available: true,
+  };
+
+  // Memory + learning loops — SONA / ReasoningBank (stable namespace, ADR-256 step 3)
+  primitives.memory = {
+    name: 'sona+reasoningbank',
+    role: 'persistent memory + self-learning loops',
+    available: true,
+    namespace: (process.env.RUVECTOR_MEMORY_NAMESPACE || 'ruvector').trim() || 'ruvector',
+  };
+
+  const values = Object.values(primitives);
+  return {
+    adr: 'ADR-256',
+    decision: 'borrow metaharness concepts using primitives ruvector already ships',
+    primitives,
+    summary: {
+      available: values.filter((p) => p.available).length,
+      total: values.length,
+    },
+  };
+}
+
+const harnessCmd = program
+  .command('harness')
+  .description('Unified "harness router" surface — cost router + semantic router + hooks routing + MCP + witness (ADR-256)');
+
+function printHarnessStatus(opts) {
+  const surface = buildHarnessSurface();
+  if (opts && opts.json) {
+    console.log(JSON.stringify(surface, null, 2));
+    return;
+  }
+  console.log(chalk.cyan('\n═══════════════════════════════════════════════════════════════'));
+  console.log(chalk.cyan('              RuVector Harness Router (ADR-256)'));
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════\n'));
+  console.log(chalk.gray('  ' + surface.decision + '\n'));
+  for (const p of Object.values(surface.primitives)) {
+    const badge = p.available ? chalk.green('● available') : chalk.yellow('○ optional ');
+    console.log(`  ${badge}  ${chalk.white(p.name)}${p.version ? chalk.dim(' v' + p.version) : ''}`);
+    console.log(`              ${chalk.dim(p.role)}`);
+    if (p.available && p.usage) console.log(`              ${chalk.dim(p.usage)}`);
+    if (!p.available && p.install) console.log(`              ${chalk.dim('install: ' + p.install)}`);
+  }
+  console.log('');
+  console.log(chalk.cyan(`  ${surface.summary.available}/${surface.summary.total} primitives available\n`));
+}
+
+harnessCmd
+  .command('status')
+  .alias('info')
+  .description('Show the unified harness routing surface and primitive availability')
+  .option('--json', 'Output as JSON')
+  .action((opts) => printHarnessStatus(opts));
+
+// Bare `ruvector harness` defaults to status
+harnessCmd.action(() => printHarnessStatus({}));
+
 program.parse();
 
 

package/bin/mcp-policy.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * MCP tool-access policy (ADR-256 — default-deny posture).
+ *
+ * Borrows metaharness's "default-deny allowlist" security concept using a small,
+ * pure, testable module. Operators restrict the exposed/callable MCP tool surface
+ * via environment variables:
+ *
+ *   RUVECTOR_MCP_ALLOW="hooks_route,hooks_recall"  → only these are exposed/callable
+ *   RUVECTOR_MCP_DENY="hooks_security_scan"        → these are blocked (wins over allow)
+ *   RUVECTOR_MCP_PROFILE=readonly                  → a curated safe subset
+ *
+ * Precedence: DENY > ALLOW/PROFILE > (default allow-all).
+ * With no policy configured, all registered tools are allowed (backward compatible);
+ * `policy.configured` is false so the server can nudge toward an allowlist.
+ *
+ * This module is dependency-free and side-effect-free so it can be unit-tested
+ * without spawning an MCP stdio server.
+ */
+
+/** Curated read-only / low-risk tool subsets. */
+const MCP_PROFILES = {
+  readonly: [
+    'ruvector',
+    'hooks_stats',
+    'hooks_recall',
+    'hooks_route',
+    'hooks_route_enhanced',
+    'hooks_suggest_context',
+    'hooks_capabilities',
+    'hooks_export',
+    'hooks_doctor',
+    'hooks_attention_info',
+    'hooks_gnn_info',
+  ],
+};
+
+/** Split a comma/space separated env list into a clean array. */
+function parseList(value) {
+  if (!value || typeof value !== 'string') return [];
+  return value
+    .split(/[,\s]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Build a tool-access policy from an env-like object (defaults to process.env).
+ * Returns { allowSet: Set|null, deny: Set, profile: string|null, configured: bool }.
+ */
+function buildToolPolicy(env) {
+  const e = env || process.env;
+  const allow = parseList(e.RUVECTOR_MCP_ALLOW);
+  const deny = new Set(parseList(e.RUVECTOR_MCP_DENY));
+  const profileName = e.RUVECTOR_MCP_PROFILE && e.RUVECTOR_MCP_PROFILE.trim();
+
+  let allowSet = null;
+  if (profileName && MCP_PROFILES[profileName]) {
+    allowSet = new Set(MCP_PROFILES[profileName]);
+  }
+  if (allow.length) {
+    allowSet = new Set([...(allowSet || []), ...allow]);
+  }
+
+  return {
+    allowSet,
+    deny,
+    profile: profileName && MCP_PROFILES[profileName] ? profileName : null,
+    // An unknown profile name with no allow/deny is treated as "not configured".
+    configured: Boolean(allowSet || deny.size),
+  };
+}
+
+/** Is a tool name permitted under the given policy? DENY always wins. */
+function isToolAllowed(name, policy) {
+  if (!policy) return true;
+  if (policy.deny.has(name)) return false;
+  if (policy.allowSet) return policy.allowSet.has(name);
+  return true;
+}
+
+/** Filter a TOOLS array (objects with a `.name`) down to the allowed subset. */
+function filterAllowedTools(tools, policy) {
+  if (!Array.isArray(tools)) return [];
+  return tools.filter((t) => t && isToolAllowed(t.name, policy));
+}
+
+module.exports = {
+  MCP_PROFILES,
+  parseList,
+  buildToolPolicy,
+  isToolAllowed,
+  filterAllowedTools,
+};

package/bin/mcp-server.js

@@ -26,6 +26,10 @@ const path = require('path');
 const fs = require('fs');
 const { execSync, execFileSync } = require('child_process');
 
+// ADR-256: default-deny MCP tool-access policy (RUVECTOR_MCP_ALLOW/DENY/PROFILE)
+const { buildToolPolicy, isToolAllowed, filterAllowedTools } = require('./mcp-policy.js');
+const MCP_TOOL_POLICY = buildToolPolicy(process.env);
+
 // ── Security Helpers ────────────────────────────────────────────────────────
 
 /**
@@ -1692,15 +1696,30 @@ const TOOLS = [
   }
 ];
 
-// List tools handler
+// List tools handler — only expose tools permitted by the access policy (ADR-256)
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools: TOOLS };
+  return { tools: filterAllowedTools(TOOLS, MCP_TOOL_POLICY) };
 });
 
 // Call tool handler
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
+  // ADR-256 default-deny gate: refuse tools excluded by RUVECTOR_MCP_ALLOW/DENY/PROFILE
+  if (!isToolAllowed(name, MCP_TOOL_POLICY)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: false,
+          error: `Tool '${name}' is denied by the MCP access policy (ADR-256). ` +
+            `Adjust RUVECTOR_MCP_ALLOW / RUVECTOR_MCP_DENY / RUVECTOR_MCP_PROFILE to permit it.`,
+        }, null, 2),
+      }],
+      isError: true,
+    };
+  }
+
   try {
     switch (name) {
       case 'hooks_stats': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "description": "Self-learning vector database for Node.js \u2014 hybrid search, Graph RAG, FlashAttention-3, HNSW, 50+ attention mechanisms",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,11 +8,11 @@
     "ruvector": "./bin/cli.js"
   },
   "scripts": {
-    "build": "tsc && mkdir -p dist/core/onnx && cp -r src/core/onnx/. dist/core/onnx/",
+    "build": "tsc && node -e \"require('fs').cpSync('src/core/onnx','dist/core/onnx',{recursive:true})\"",
     "verify-dist": "node scripts/verify-dist.js",
     "prepack": "npm run build && npm run verify-dist",
     "prepublishOnly": "npm run build && npm run verify-dist",
-    "test": "node test/integration.js && node test/cli-commands.js && node test/db-workflow.js && node test/sigterm-cleanup.js"
+    "test": "node test/integration.js && node test/cli-commands.js && node test/db-workflow.js && node test/sigterm-cleanup.js && node test/mcp-policy.js && node test/startup-budget.js"
   },
   "keywords": [
     "vector",