thumbgate 1.35.0 → 1.37.1

package/src/index.js

@@ -1,3 +1,32 @@
 'use strict';
 
-module.exports = require('../scripts/feedback-loop');
+const feedbackLoop = require('../scripts/feedback-loop');
+const {
+  HermesPlatformProtocol,
+  ProtocolError,
+  CONSEQUENTIAL_ACTIONS,
+  VALID_APPROVAL_SURFACES,
+  INVALID_APPROVAL_SURFACES,
+  THREAD_MODES,
+  FORBIDDEN_IDENTITIES,
+  isNamedIdentity,
+} = require('./hermes-platform-protocol');
+const { HermesSyncPlane } = require('./hermes-sync-plane');
+
+// The package entry point is the production surface for `thumbgate`.
+// The hosted-Hermes identity/lifecycle/approval gates are exported here so
+// callers instantiate them from the public API rather than reaching into
+// module paths. See docs: hosted Hermes requests route through
+// HermesPlatformProtocol for turn lifecycle + approvals, and through
+// HermesSyncPlane for the authorized-shape read path.
+module.exports = Object.assign({}, feedbackLoop, {
+  HermesPlatformProtocol,
+  HermesSyncPlane,
+  ProtocolError,
+  CONSEQUENTIAL_ACTIONS,
+  VALID_APPROVAL_SURFACES,
+  INVALID_APPROVAL_SURFACES,
+  THREAD_MODES,
+  FORBIDDEN_IDENTITIES,
+  isNamedIdentity,
+});

package/src/iso42001-compliance-guard.js

@@ -0,0 +1,97 @@
+'use strict';
+
+/**
+ * ISO/IEC 42001:2023 Artificial Intelligence Management System (AIMS) Compliance Guard.
+ *
+ * Maps ThumbGate's pre-action gates and telemetry to formal ISO 42001 governance clauses:
+ * - Clause 6.1.2: AI Risk Assessment & Tiering
+ * - Clause 8.2:   AI Impact Assessment & Tool Blast Radius Control
+ * - Clause 8.4:   Data Lifecycle & Secret/PII Leakage Prevention
+ * - Clause 9.1:   Continuous Telemetry & SLA/SLO Monitoring
+ * - Clause 10.1:  Continuous Improvement via Feedback-to-Enforcement Rules
+ */
+
+const ISO_42001_CLAUSES = Object.freeze({
+  RISK_ASSESSMENT: 'Clause 6.1.2 (AI Risk Assessment)',
+  IMPACT_ASSESSMENT: 'Clause 8.2 (AI Impact Assessment)',
+  DATA_PROTECTION: 'Clause 8.4 (Data Lifecycle & DLP)',
+  CONTINUOUS_MONITORING: 'Clause 9.1 (Monitoring & Telemetry)',
+  CORRECTIVE_ACTION: 'Clause 10.1 (Corrective Action & Rule Promotion)',
+});
+
+class ISO42001ComplianceGuard {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  static evaluateToolCallCompliance(toolCall = {}) {
+    const findings = [];
+    const name = toolCall.name || toolCall.toolName || 'unknown';
+    const params = toolCall.parameters || toolCall.args || {};
+    const riskTier = toolCall.riskTier || 'minimal-impact';
+
+    // Clause 6.1.2: Risk Assessment
+    if (!['read-only', 'minimal-impact', 'contained-write', 'critical'].includes(riskTier)) {
+      findings.push({
+        clause: ISO_42001_CLAUSES.RISK_ASSESSMENT,
+        severity: 'FAIL',
+        message: `Unclassified risk tier '${riskTier}' on tool ${name}`,
+      });
+    }
+
+    // Clause 8.2: Blast Radius
+    if (riskTier === 'critical' && !toolCall.humanApproval && !toolCall.approvedByPolicy) {
+      findings.push({
+        clause: ISO_42001_CLAUSES.IMPACT_ASSESSMENT,
+        severity: 'FAIL',
+        message: `Critical tool call '${name}' requires explicit policy approval or human sign-off`,
+      });
+    }
+
+    // Clause 8.4: Data Protection / Secret Scanning
+    const paramStr = JSON.stringify(params);
+    const hasSecretPattern = /(?:ghp_[a-z0-9]{20,}|sk_live_[a-z0-9]{20,}|mock_secret_[a-z0-9]{10,}|-----BEGIN PRIVATE KEY-----)/i.test(paramStr);
+    if (hasSecretPattern) {
+      findings.push({
+        clause: ISO_42001_CLAUSES.DATA_PROTECTION,
+        severity: 'FAIL',
+        message: `Potential credential or secret detected in parameters for tool '${name}'`,
+      });
+    }
+
+    const compliant = findings.filter((f) => f.severity === 'FAIL').length === 0;
+
+    return {
+      compliant,
+      standard: 'ISO/IEC 42001:2023',
+      toolName: name,
+      riskTier,
+      findings,
+      timestamp: Date.now(),
+    };
+  }
+
+  static generateComplianceAuditReport(toolCalls = []) {
+    const results = toolCalls.map((tc) => ISO42001ComplianceGuard.evaluateToolCallCompliance(tc));
+    const total = results.length;
+    const passed = results.filter((r) => r.compliant).length;
+    const failed = total - passed;
+
+    return {
+      standard: 'ISO/IEC 42001:2023 AIMS',
+      auditTimestamp: new Date().toISOString(),
+      summary: {
+        totalEvaluated: total,
+        passed,
+        failed,
+        complianceRate: total > 0 ? (passed / total) * 100 : 100,
+      },
+      records: results,
+    };
+  }
+}
+
+module.exports = {
+  ISO42001ComplianceGuard,
+  ISO_42001_CLAUSES,
+};

package/src/latency-budget.js

@@ -0,0 +1,244 @@
+'use strict';
+
+/**
+ * ThumbGate Agent Hop-Latency Budget & Fast-Path Engine
+ *
+ * Grounded in 2026 Enterprise Latency Benchmarks (The New Stack / Akamai / LangChain):
+ * - 82% of enterprises require <=500ms response times; 64% require <=250ms.
+ * - CPU/WAN multi-hop processing accounts for up to 90.6% of agent chain latency.
+ * - Tracks per-hop execution budgets, isolates CPU-side bottlenecks, and enforces fast-path local execution.
+ */
+
+const PROFILES = {
+  INTERACTIVE_VOICE: {
+    name: 'interactive_voice',
+    slaMs: 250,
+    budgets: {
+      reasoning_inference: 100,
+      governance_gate: 15,
+      tool_dispatch_transport: 75,
+      cpu_data_processing: 35,
+      memory_recall: 25,
+    },
+  },
+  STANDARD_AGENT: {
+    name: 'standard_agent',
+    slaMs: 500,
+    budgets: {
+      reasoning_inference: 200,
+      governance_gate: 25,
+      tool_dispatch_transport: 150,
+      cpu_data_processing: 75,
+      memory_recall: 50,
+    },
+  },
+  BATCH_WORKFLOW: {
+    name: 'batch_workflow',
+    slaMs: 5000,
+    budgets: {
+      reasoning_inference: 2500,
+      governance_gate: 200,
+      tool_dispatch_transport: 1300,
+      cpu_data_processing: 600,
+      memory_recall: 400,
+    },
+  },
+};
+
+class LatencyTracker {
+  /**
+   * @param {'standard_agent'|'interactive_voice'|'batch_workflow'|Object} [profile='standard_agent']
+   */
+  constructor(profile = 'standard_agent') {
+    if (typeof profile === 'string') {
+      this.profile = PROFILES[profile.toUpperCase()] || PROFILES.STANDARD_AGENT;
+    } else if (typeof profile === 'object' && profile.slaMs) {
+      this.profile = profile;
+    } else {
+      this.profile = PROFILES.STANDARD_AGENT;
+    }
+
+    this.hops = [];
+    this.activeHops = new Map();
+    this.sessionStartTime = Date.now();
+  }
+
+  /**
+   * Starts timing a specific hop.
+   * @param {string} phase e.g. 'reasoning_inference', 'governance_gate', 'tool_dispatch_transport'
+   * @param {string} [label] descriptive label
+   * @returns {string} hopId
+   */
+  startHop(phase, label = '') {
+    const hopId = `hop_${this.hops.length + 1}_${Date.now()}`;
+    const startMs = Date.now();
+    this.activeHops.set(hopId, {
+      hopId,
+      phase,
+      label: label || phase,
+      startMs,
+      endMs: null,
+      durationMs: null,
+    });
+    return hopId;
+  }
+
+  /**
+   * Ends timing a specific hop.
+   * @param {string} hopId
+   * @param {Object} [metadata]
+   * @returns {Object} recorded hop
+   */
+  endHop(hopId, metadata = {}) {
+    const active = this.activeHops.get(hopId);
+    if (!active) {
+      throw new Error(`Unknown active hop ID: ${hopId}`);
+    }
+
+    const endMs = Date.now();
+    const durationMs = Math.max(0, endMs - active.startMs);
+    const completed = {
+      ...active,
+      endMs,
+      durationMs,
+      metadata,
+    };
+
+    this.activeHops.delete(hopId);
+    this.hops.push(completed);
+    return completed;
+  }
+
+  /**
+   * Directly records a completed hop duration.
+   * @param {string} phase
+   * @param {number} durationMs
+   * @param {string} [label]
+   * @param {Object} [metadata]
+   */
+  recordHop(phase, durationMs, label = '', metadata = {}) {
+    const now = Date.now();
+    const hop = {
+      hopId: `hop_${this.hops.length + 1}_${now}`,
+      phase,
+      label: label || phase,
+      startMs: now - durationMs,
+      endMs: now,
+      durationMs: Math.max(0, durationMs),
+      metadata,
+    };
+    this.hops.push(hop);
+    return hop;
+  }
+
+  /**
+   * Analyzes all recorded hops against performance SLA and budget limits.
+   * @returns {Object} analysis summary
+   */
+  analyze() {
+    let totalDurationMs = 0;
+    let cpuDurationMs = 0;
+    let gpuDurationMs = 0;
+    const phaseTotals = {};
+    const breachedPhases = [];
+
+    for (const hop of this.hops) {
+      const dur = hop.durationMs;
+      totalDurationMs += dur;
+      phaseTotals[hop.phase] = (phaseTotals[hop.phase] || 0) + dur;
+
+      if (hop.phase === 'reasoning_inference') {
+        gpuDurationMs += dur;
+      } else {
+        cpuDurationMs += dur;
+      }
+    }
+
+    const budgets = this.profile.budgets || {};
+    for (const [phase, budgetMs] of Object.entries(budgets)) {
+      const actual = phaseTotals[phase] || 0;
+      if (actual > budgetMs) {
+        breachedPhases.push({
+          phase,
+          budgetMs,
+          actualMs: actual,
+          excessMs: actual - budgetMs,
+        });
+      }
+    }
+
+    const cpuRatio = totalDurationMs > 0 ? Number((cpuDurationMs / totalDurationMs).toFixed(3)) : 0;
+    const meetsSla = totalDurationMs <= this.profile.slaMs;
+    const cpuBottleneck = cpuRatio >= 0.7; // >70% latency spent outside model reasoning
+
+    return {
+      profile: this.profile.name,
+      slaMs: this.profile.slaMs,
+      totalDurationMs,
+      meetsSla,
+      cpuDurationMs,
+      gpuDurationMs,
+      cpuRatio,
+      cpuBottleneck,
+      hopCount: this.hops.length,
+      phaseTotals,
+      breachedPhases,
+      recommendations: this._generateRecommendations(meetsSla, cpuBottleneck, breachedPhases),
+    };
+  }
+
+  /**
+   * Generates actionable remediation recommendations.
+   * @private
+   */
+  _generateRecommendations(meetsSla, cpuBottleneck, breachedPhases) {
+    const recs = [];
+    if (!meetsSla) {
+      recs.push(`Target SLA missed by ${this.analyzeTotalExcess()}ms. Activate local fast-path edge caching.`);
+    }
+    if (cpuBottleneck) {
+      recs.push('High CPU/transport ratio (>70%). Co-locate MCP tools with local ThumbGate gateway to eliminate WAN roundtrips.');
+    }
+    for (const breach of breachedPhases) {
+      if (breach.phase === 'governance_gate') {
+        recs.push(`Governance phase exceeded budget (${breach.actualMs}ms vs ${breach.budgetMs}ms). Switch to asynchronous scrubbed audit trail.`);
+      } else if (breach.phase === 'tool_dispatch_transport') {
+        recs.push(`Tool transport exceeded budget (${breach.actualMs}ms vs ${breach.budgetMs}ms). Batch parallel tool executions.`);
+      }
+    }
+    return recs;
+  }
+
+  /**
+   * Calculates total excess ms over SLA.
+   * @private
+   */
+  analyzeTotalExcess() {
+    const total = this.hops.reduce((acc, h) => acc + h.durationMs, 0);
+    return Math.max(0, total - this.profile.slaMs);
+  }
+
+  /**
+   * Exports OpenTelemetry-compliant trace span attributes.
+   * @returns {Object}
+   */
+  exportOtelAttributes() {
+    const report = this.analyze();
+    return {
+      'agent.latency.profile': report.profile,
+      'agent.latency.sla_ms': report.slaMs,
+      'agent.latency.total_ms': report.totalDurationMs,
+      'agent.latency.cpu_ms': report.cpuDurationMs,
+      'agent.latency.gpu_ms': report.gpuDurationMs,
+      'agent.latency.cpu_ratio': report.cpuRatio,
+      'agent.latency.cpu_bottleneck': report.cpuBottleneck,
+      'agent.latency.meets_sla': report.meetsSla,
+      'agent.latency.hop_count': report.hopCount,
+    };
+  }
+}
+
+module.exports = {
+  PROFILES,
+  LatencyTracker,
+};

package/src/mcp-writeguard.js

@@ -0,0 +1,316 @@
+'use strict';
+
+/**
+ * ThumbGate WriteGuard — Fine-Grained Pre-Action MCP Governance Engine
+ *
+ * Inspired by Cloudflare WriteGuard & ThumbGate Reliability Gateway:
+ * - Intercepts incoming MCP tool calls without upstream server modification
+ * - Classifies tool risk tiers (read, write, privileged_write, admin)
+ * - Evaluates request context against deterministic safety policies
+ * - Scrubs sensitive tokens/secrets from audit payloads
+ * - Emits structured attribution receipts with user, client, session, and duration metadata
+ */
+
+const crypto = require('node:crypto');
+
+const RISK_TIERS = {
+  READ: 'read',
+  WRITE: 'write',
+  PRIVILEGED_WRITE: 'privileged_write',
+  ADMIN: 'admin',
+};
+
+const DEFAULT_READ_TOOLS = new Set([
+  'view_file',
+  'read_file',
+  'list_dir',
+  'find_by_name',
+  'grep_search',
+  'read_resource',
+  'list_resources',
+  'search_web',
+  'read_url_content',
+  'get_scope_state',
+  'get_branch_governance',
+  'get_action_receipts',
+  'get_task_outcomes',
+  'get_business_metrics',
+  'estimate_uncertainty',
+  'recall',
+  'feedback_summary',
+  'search_lessons',
+  'retrieve_lessons',
+  'dashboard',
+]);
+
+const DEFAULT_WRITE_TOOLS = new Set([
+  'write_to_file',
+  'replace_file_content',
+  'edit_file',
+  'generate_image',
+  'capture_feedback',
+  'capture_memory_feedback',
+  'record_action_receipt',
+  'record_task_outcome',
+  'track_action',
+]);
+
+const DEFAULT_PRIVILEGED_TOOLS = new Set([
+  'run_command',
+  'execute_command',
+  'bash',
+  'manage_task',
+  'kill',
+  'create_purchase_requisition',
+  'settle_purchase_requisition',
+  'browser_run_code_unsafe',
+  'browser_evaluate',
+]);
+
+const DEFAULT_ADMIN_TOOLS = new Set([
+  'set_branch_governance',
+  'approve_protected_action',
+  'register_claim_gate',
+  'define_subagent',
+  'manage_subagents',
+  'satisfy_gate',
+]);
+
+const DANGEROUS_COMMAND_PATTERNS = [
+  /rm\s+-rf\s+[/~]/i,
+  /drop\s+table/i,
+  /drop\s+database/i,
+  /truncate\s+table/i,
+  /git\s+push\s+[\s\S]*?--force/i,
+  /git\s+reset\s+--hard/i,
+  /chmod\s+777/i,
+  /mkfs/i,
+  />\s*\/dev\/sd[a-z]/i,
+  /:()\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/i, // fork bomb
+];
+
+const SENSITIVE_KEY_PATTERNS = [
+  /api[_-]?key/i,
+  /auth[_-]?token/i,
+  /access[_-]?token/i,
+  /bearer/i,
+  /password/i,
+  /passwd/i,
+  /secret/i,
+  /private[_-]?key/i,
+  /credentials/i,
+  /stripe[_-]?key/i,
+  /github[_-]?pat/i,
+  /^(authorization|proxy[_-]?authorization|cookie|set[_-]?cookie)$/i,
+  /x[_-]?relay/i,
+];
+
+const CREDENTIAL_HEADER_KEYS = /^(authorization|proxy-authorization|cookie|set-cookie)$/i;
+
+/**
+ * Classifies an MCP tool into a risk tier.
+ * @param {string} toolName
+ * @param {Object} [customPolicies]
+ * @returns {'read'|'write'|'privileged_write'|'admin'}
+ */
+function classifyMcpTool(toolName, customPolicies = {}) {
+  if (!toolName || typeof toolName !== 'string') return RISK_TIERS.READ;
+  const name = toolName.trim();
+
+  if (customPolicies[name] && customPolicies[name].tier) {
+    return customPolicies[name].tier;
+  }
+
+  if (DEFAULT_ADMIN_TOOLS.has(name)) return RISK_TIERS.ADMIN;
+  if (DEFAULT_PRIVILEGED_TOOLS.has(name)) return RISK_TIERS.PRIVILEGED_WRITE;
+  if (DEFAULT_WRITE_TOOLS.has(name)) return RISK_TIERS.WRITE;
+  if (DEFAULT_READ_TOOLS.has(name)) return RISK_TIERS.READ;
+
+  // Heuristic fallbacks for custom/MCP servers
+  if (/^(delete|drop|destroy|purge|remove|kill|admin|grant|revoke)/i.test(name)) {
+    return RISK_TIERS.PRIVILEGED_WRITE;
+  }
+  if (/^(create|write|update|set|put|post|patch|insert|modify|send)/i.test(name)) {
+    return RISK_TIERS.WRITE;
+  }
+
+  return RISK_TIERS.READ;
+}
+
+/**
+ * Scrub credential-bearing string values (headers and inline tokens).
+ * @param {string} value
+ * @returns {string}
+ */
+function scrubSensitiveString(value) {
+  let out = value;
+  if (/-----BEGIN\s+(RSA|OPENSSH|PRIVATE)\s+KEY-----/i.test(out)) {
+    return '[REDACTED_PRIVATE_KEY]';
+  }
+  if (/\bbearer\s+[a-zA-Z0-9_\-.]{20,}/i.test(out)) {
+    out = out.replace(/\bbearer\s+[a-zA-Z0-9_\-.]{20,}/gi, 'Bearer [REDACTED]');
+  }
+  if (/\bbasic\s+[a-zA-Z0-9+/=_-]{8,}/i.test(out)) {
+    out = out.replace(/\bbasic\s+[a-zA-Z0-9+/=_-]{8,}/gi, 'Basic [REDACTED]');
+  }
+  // Cookie / Set-Cookie style values (name=value pairs with auth-ish names)
+  if (
+    /(?:^|;\s*)(?:session|sid|token|auth|jwt|refresh)[^=]*=[^;]+/i.test(out)
+    || (/^[^=;\s]+=[^;]+(?:;\s*[^=;\s]+=[^;]+)*$/.test(out.trim())
+      && /(session|token|sid|auth|jwt|secret)/i.test(out))
+  ) {
+    return '[REDACTED_COOKIE]';
+  }
+  return out;
+}
+
+/**
+ * Recursively scrubs secret keys and values from parameter objects.
+ * @param {*} value
+ * @returns {*}
+ */
+function scrubSensitiveData(value) {
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string') {
+    return scrubSensitiveString(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(scrubSensitiveData);
+  }
+
+  if (typeof value === 'object') {
+    const scrubbed = {};
+    for (const [k, v] of Object.entries(value)) {
+      const isSensitiveKey = SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(k))
+        || CREDENTIAL_HEADER_KEYS.test(String(k).trim());
+      if (isSensitiveKey) {
+        scrubbed[k] = '[REDACTED]';
+      } else {
+        scrubbed[k] = scrubSensitiveData(v);
+      }
+    }
+    return scrubbed;
+  }
+
+  return value;
+}
+
+/**
+ * Inspects parameters for dangerous destructive operations.
+ * @param {string} toolName
+ * @param {Object} parameters
+ * @returns {Array<string>} list of violation reasons
+ */
+function scanForDestructivePatterns(toolName, parameters) {
+  const violations = [];
+  if (!parameters || typeof parameters !== 'object') return violations;
+
+  const serialized = JSON.stringify(parameters);
+  for (const pat of DANGEROUS_COMMAND_PATTERNS) {
+    if (pat.test(serialized)) {
+      violations.push(`Dangerous destructive pattern detected matching ${pat.toString()}`);
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Evaluates an incoming MCP call and produces an attribution receipt.
+ * @param {Object} callRequest
+ * @param {string} callRequest.server
+ * @param {string} callRequest.tool
+ * @param {Object} callRequest.parameters
+ * @param {Object} [callRequest.context]
+ * @param {Object} [options]
+ * @returns {Object} evaluation receipt
+ */
+function evaluateMcpCall(callRequest, options = {}) {
+  const startTime = Date.now();
+  const server = callRequest.server || 'default';
+  const tool = callRequest.tool || 'unknown';
+  const parameters = callRequest.parameters || {};
+  const context = callRequest.context || {};
+  const customPolicies = options.customPolicies || {};
+
+  const riskTier = classifyMcpTool(tool, customPolicies);
+  // Destructive command patterns apply to executable/write tiers only.
+  // Read tools (retrieve_lessons, recall, search) legitimately quote
+  // force-push / rm -rf text as lesson queries — scanning those is a false deny.
+  const violations = riskTier === RISK_TIERS.READ
+    ? []
+    : scanForDestructivePatterns(tool, parameters);
+
+  let decision = 'allowed';
+  const reasons = [...violations];
+
+  // Evaluate tier restrictions
+  if (violations.length > 0) {
+    decision = 'blocked';
+  } else if (riskTier === RISK_TIERS.ADMIN && !options.allowAdmin) {
+    decision = 'escalated';
+    reasons.push(`Tool ${tool} is in admin tier and requires explicit operator approval`);
+  } else if (riskTier === RISK_TIERS.PRIVILEGED_WRITE && options.requireReviewForPrivileged) {
+    decision = 'escalated';
+    reasons.push(`Tool ${tool} is in privileged_write tier and requires human review`);
+  }
+
+  const durationMs = Math.max(0, Date.now() - startTime);
+  const eventId = `wg_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+
+  const receipt = {
+    eventId,
+    timestamp: new Date().toISOString(),
+    server,
+    tool,
+    riskTier,
+    decision,
+    user: context.user || 'operator',
+    client: context.client || 'mcp-client',
+    sessionId: context.sessionId || 'default-session',
+    durationMs,
+    reasons,
+    parameters: scrubSensitiveData(parameters),
+  };
+
+  return receipt;
+}
+
+/**
+ * Exports a Cloudflare WriteGuard compatible JSON policy schema.
+ * @param {Array<string>} toolNames
+ * @param {Object} [overrides]
+ * @returns {Object}
+ */
+function exportCloudflareWriteGuardPolicy(toolNames = [], overrides = {}) {
+  const policies = {};
+
+  for (const name of toolNames) {
+    const tier = classifyMcpTool(name, overrides);
+    policies[name] = {
+      riskTier: tier,
+      action: tier === RISK_TIERS.ADMIN ? 'escalate' : tier === RISK_TIERS.PRIVILEGED_WRITE ? 'guard' : 'allow',
+      audit: true,
+      redactSecrets: true,
+      maxExecutionMs: tier === RISK_TIERS.READ ? 2000 : 10000,
+    };
+  }
+
+  return {
+    version: '1.0',
+    generatedAt: new Date().toISOString(),
+    engine: 'ThumbGate-WriteGuard',
+    defaultAction: 'allow',
+    policies,
+  };
+}
+
+module.exports = {
+  RISK_TIERS,
+  classifyMcpTool,
+  scrubSensitiveData,
+  scanForDestructivePatterns,
+  evaluateMcpCall,
+  exportCloudflareWriteGuardPolicy,
+};