moflo 4.8.21 → 4.8.22

package/src/@claude-flow/guidance/dist/ruvbot-integration.js

@@ -1,738 +0,0 @@
-/**
- * RuvBot Integration Bridge
- *
- * Bridges ruvbot (npm: ruvbot@0.1.8) with the @claude-flow/guidance control
- * plane. Wires ruvbot events to guidance hooks, wraps AIDefence as an
- * enforcement gate, governs memory operations, and feeds trust accumulation.
- *
- * ruvbot is an optional peer dependency. All types and classes are exported
- * regardless of whether ruvbot is installed. Runtime calls that require the
- * ruvbot package will throw a clear error if the package is missing.
- *
- * Components:
- * 1. RuvBotGuidanceBridge  - Event wiring, gate delegation, trust tracking
- * 2. AIDefenceGate         - Prompt injection, jailbreak, PII detection gate
- * 3. RuvBotMemoryAdapter   - Governed memory read/write with proof logging
- *
- * @module @claude-flow/guidance/ruvbot-integration
- */
-// ============================================================================
-// Severity Mapping
-// ============================================================================
-/** Maps blockThreshold to a minimum severity that triggers a block. */
-const BLOCK_SEVERITY_THRESHOLDS = {
-    low: new Set(['low', 'medium', 'high', 'critical']),
-    medium: new Set(['medium', 'high', 'critical']),
-    high: new Set(['high', 'critical']),
-};
-/** Maps ruvbot threat type strings to our typed threat type. */
-const THREAT_TYPE_MAP = {
-    'prompt-injection': 'prompt-injection',
-    'prompt_injection': 'prompt-injection',
-    'promptInjection': 'prompt-injection',
-    'jailbreak': 'jailbreak',
-    'pii': 'pii',
-    'control-chars': 'control-chars',
-    'control_chars': 'control-chars',
-    'controlChars': 'control-chars',
-    'homoglyph': 'homoglyph',
-};
-/** Maps ruvbot severity strings to our typed severity. */
-const SEVERITY_MAP = {
-    low: 'low',
-    medium: 'medium',
-    high: 'high',
-    critical: 'critical',
-};
-// ============================================================================
-// Dynamic Import Helper
-// ============================================================================
-/** Resolved ruvbot module cache (null = not attempted, undefined = failed). */
-let ruvbotModuleCache = null;
-/**
- * Module specifiers kept in variables so TypeScript does not attempt
- * compile-time resolution of this optional peer dependency.
- */
-const RUVBOT_MODULE = 'ruvbot';
-const RUVBOT_CORE_MODULE = 'ruvbot/core';
-/**
- * Attempt to dynamically import the ruvbot package.
- * Throws a descriptive error if the package is not installed.
- */
-async function requireRuvBot() {
-    if (ruvbotModuleCache)
-        return ruvbotModuleCache;
-    try {
-        const mod = await import(RUVBOT_MODULE);
-        ruvbotModuleCache = mod;
-        return mod;
-    }
-    catch {
-        throw new Error('ruvbot is not installed. Install it with: npm install ruvbot@0.1.8\n' +
-            'ruvbot is an optional peer dependency of @claude-flow/guidance.');
-    }
-}
-/**
- * Attempt to dynamically import ruvbot/core sub-export.
- */
-async function requireRuvBotCore() {
-    try {
-        return await import(RUVBOT_CORE_MODULE);
-    }
-    catch {
-        // Fall back to the main export
-        return requireRuvBot();
-    }
-}
-// ============================================================================
-// AIDefenceGate
-// ============================================================================
-/**
- * Wraps ruvbot's 6-layer AIDefence as an enforcement gate compatible with the
- * guidance control plane's GateResult / GateDecision interface.
- *
- * Supports:
- * - Prompt injection detection
- * - Jailbreak detection
- * - PII detection
- * - Control character and homoglyph detection (via ruvbot internals)
- * - Configurable sensitivity / block threshold
- *
- * Evaluates both input (pre-processing) and output (post-processing) text.
- */
-export class AIDefenceGate {
-    config;
-    guard = null;
-    guardInitPromise = null;
-    constructor(config = {}) {
-        this.config = {
-            detectPromptInjection: config.detectPromptInjection ?? true,
-            detectJailbreak: config.detectJailbreak ?? true,
-            detectPII: config.detectPII ?? true,
-            blockThreshold: config.blockThreshold ?? 'medium',
-        };
-    }
-    /**
-     * Lazily initialize the underlying ruvbot AIDefence guard.
-     * Safe to call multiple times; only the first call creates the guard.
-     */
-    async ensureGuard() {
-        if (this.guard)
-            return this.guard;
-        if (!this.guardInitPromise) {
-            this.guardInitPromise = (async () => {
-                const mod = await requireRuvBot();
-                const createGuard = mod['createAIDefenceGuard'];
-                if (typeof createGuard !== 'function') {
-                    throw new Error('ruvbot does not export createAIDefenceGuard. ' +
-                        'Ensure ruvbot@0.1.8 or later is installed.');
-                }
-                this.guard = createGuard({
-                    detectPromptInjection: this.config.detectPromptInjection,
-                    detectJailbreak: this.config.detectJailbreak,
-                    detectPII: this.config.detectPII,
-                });
-            })();
-        }
-        await this.guardInitPromise;
-        return this.guard;
-    }
-    /**
-     * Evaluate input text for threats (pre-processing gate).
-     *
-     * Checks for prompt injection, jailbreak attempts, and PII based
-     * on the configured sensitivity.
-     */
-    async evaluateInput(input) {
-        const start = performance.now();
-        const guard = await this.ensureGuard();
-        const raw = await guard.check(input);
-        const latencyMs = performance.now() - start;
-        const threats = this.normalizeThreats(raw.threats);
-        return {
-            safe: raw.safe,
-            threats,
-            sanitizedInput: raw.sanitizedInput,
-            latencyMs,
-        };
-    }
-    /**
-     * Evaluate output text for threats (post-processing gate).
-     *
-     * Primarily checks for PII leakage and secret exposure in responses.
-     */
-    async evaluateOutput(output) {
-        const start = performance.now();
-        const guard = await this.ensureGuard();
-        const raw = await guard.check(output);
-        const latencyMs = performance.now() - start;
-        // For output evaluation, focus on PII / data leakage threats
-        const threats = this.normalizeThreats(raw.threats).filter(t => t.type === 'pii' || t.type === 'control-chars');
-        return {
-            safe: threats.length === 0,
-            threats,
-            sanitizedInput: raw.sanitizedInput,
-            latencyMs,
-        };
-    }
-    /**
-     * Convert an AIDefenceResult into a GateResult compatible with the
-     * guidance enforcement pipeline.
-     *
-     * Decision logic:
-     * - If no threats: 'allow'
-     * - If threats above block threshold: 'block'
-     * - Otherwise: 'warn'
-     */
-    toGateResult(result, context) {
-        if (result.safe && result.threats.length === 0) {
-            return {
-                decision: 'allow',
-                gateName: 'ai-defence',
-                reason: 'AIDefence check passed with no threats detected.',
-                triggeredRules: [],
-                metadata: { latencyMs: result.latencyMs },
-            };
-        }
-        const blockingSeverities = BLOCK_SEVERITY_THRESHOLDS[this.config.blockThreshold];
-        const blockingThreats = result.threats.filter(t => blockingSeverities.has(t.severity));
-        const decision = blockingThreats.length > 0 ? 'block' : 'warn';
-        const threatSummary = result.threats
-            .map(t => `${t.type} (${t.severity}): ${t.detail}`)
-            .join('; ');
-        return {
-            decision,
-            gateName: 'ai-defence',
-            reason: `AIDefence detected ${result.threats.length} threat(s): ${threatSummary}`,
-            triggeredRules: [],
-            remediation: this.buildRemediation(result.threats),
-            metadata: {
-                threats: result.threats,
-                blockThreshold: this.config.blockThreshold,
-                latencyMs: result.latencyMs,
-                context,
-            },
-        };
-    }
-    /**
-     * Get the current configuration.
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update configuration. Resets the guard so the next evaluation
-     * re-initializes with the new settings.
-     */
-    updateConfig(config) {
-        this.config = { ...this.config, ...config };
-        this.guard = null;
-        this.guardInitPromise = null;
-    }
-    // ===== Private Helpers =====
-    normalizeThreats(raw) {
-        return raw.map(t => ({
-            type: THREAT_TYPE_MAP[t.type] ?? 'prompt-injection',
-            severity: SEVERITY_MAP[t.severity] ?? 'medium',
-            detail: t.detail,
-        }));
-    }
-    buildRemediation(threats) {
-        const parts = [];
-        const hasInjection = threats.some(t => t.type === 'prompt-injection');
-        const hasJailbreak = threats.some(t => t.type === 'jailbreak');
-        const hasPII = threats.some(t => t.type === 'pii');
-        if (hasInjection) {
-            parts.push('1. Review input for prompt injection patterns and remove adversarial content.');
-        }
-        if (hasJailbreak) {
-            parts.push('2. Input contains jailbreak attempt. Reject and log the attempt.');
-        }
-        if (hasPII) {
-            parts.push('3. Redact or mask personally identifiable information before processing.');
-        }
-        if (parts.length === 0) {
-            parts.push('Review flagged content and apply appropriate sanitization.');
-        }
-        return parts.join('\n');
-    }
-}
-// ============================================================================
-// RuvBotMemoryAdapter
-// ============================================================================
-/**
- * Wraps ruvbot's memory read/write operations with guidance control plane
- * governance. Every write passes through the MemoryWriteGate for authority
- * and coherence checks. All operations are logged to a proof chain.
- */
-export class RuvBotMemoryAdapter {
-    memoryGate;
-    coherenceScheduler;
-    proofChain = null;
-    ruvbotMemory = null;
-    operationLog = [];
-    constructor(memoryGate, coherenceScheduler) {
-        this.memoryGate = memoryGate;
-        this.coherenceScheduler = coherenceScheduler;
-    }
-    /**
-     * Attach a ruvbot memory instance for proxied operations.
-     */
-    attachMemory(memory) {
-        this.ruvbotMemory = memory;
-    }
-    /**
-     * Attach a proof chain for operation logging.
-     */
-    attachProofChain(proofChain) {
-        this.proofChain = proofChain;
-    }
-    /**
-     * Governed read: reads through ruvbot memory, logs to proof chain.
-     */
-    async read(key, namespace = 'default') {
-        this.ensureMemoryAttached();
-        const value = await this.ruvbotMemory.read(key, namespace);
-        this.operationLog.push({
-            operation: 'read',
-            key,
-            namespace,
-            timestamp: Date.now(),
-        });
-        return value;
-    }
-    /**
-     * Governed write: runs through MemoryWriteGate, checks coherence,
-     * logs to proof chain, then delegates to ruvbot memory.
-     *
-     * Returns the WriteDecision. If denied, the write is not performed.
-     */
-    async write(key, namespace, value, authority, existingEntries) {
-        this.ensureMemoryAttached();
-        // Step 1: Evaluate through MemoryWriteGate
-        const decision = this.memoryGate.evaluateWrite(authority, key, namespace, value, existingEntries);
-        // Step 2: Log the operation
-        this.operationLog.push({
-            operation: 'write',
-            key,
-            namespace,
-            timestamp: Date.now(),
-            decision,
-        });
-        // Step 3: If denied, do not write
-        if (!decision.allowed) {
-            return decision;
-        }
-        // Step 4: Perform the write through ruvbot
-        await this.ruvbotMemory.write(key, value, namespace);
-        return decision;
-    }
-    /**
-     * Governed delete: checks authority, logs, then delegates.
-     */
-    async delete(key, namespace, authority) {
-        this.ensureMemoryAttached();
-        // Authority must have delete permission
-        if (!authority.canDelete) {
-            const result = {
-                allowed: false,
-                reason: `Agent "${authority.agentId}" does not have delete permission.`,
-            };
-            this.operationLog.push({
-                operation: 'delete',
-                key,
-                namespace,
-                timestamp: Date.now(),
-            });
-            return result;
-        }
-        // Perform the delete if the underlying memory supports it
-        if (typeof this.ruvbotMemory.delete === 'function') {
-            await this.ruvbotMemory.delete(key, namespace);
-        }
-        this.operationLog.push({
-            operation: 'delete',
-            key,
-            namespace,
-            timestamp: Date.now(),
-        });
-        return { allowed: true, reason: 'Delete permitted and executed.' };
-    }
-    /**
-     * Get the operation log for audit/proof purposes.
-     */
-    getOperationLog() {
-        return this.operationLog;
-    }
-    /**
-     * Get the count of governed operations.
-     */
-    get operationCount() {
-        return this.operationLog.length;
-    }
-    /**
-     * Clear the operation log.
-     */
-    clearLog() {
-        this.operationLog = [];
-    }
-    // ===== Private Helpers =====
-    ensureMemoryAttached() {
-        if (!this.ruvbotMemory) {
-            throw new Error('No ruvbot memory instance attached. Call attachMemory() before ' +
-                'performing memory operations.');
-        }
-    }
-}
-// ============================================================================
-// RuvBotGuidanceBridge
-// ============================================================================
-/**
- * Bridges a ruvbot instance with the @claude-flow/guidance control plane.
- *
- * Wires ruvbot event hooks to guidance enforcement and trust systems:
- *
- * - `message`        -> EnforcementGates (secrets, destructive ops) + AIDefence
- * - `agent:spawn`    -> ManifestValidator
- * - `session:create` -> ProofChain initialization
- * - `session:end`    -> ProofChain finalization and ledger persistence
- * - `ready`          -> Trust accumulator initialization
- * - `error`          -> Trust 'deny' outcome recording
- *
- * All gate outcomes are fed into the TrustAccumulator so that ruvbot agents
- * build (or lose) trust over time.
- */
-export class RuvBotGuidanceBridge {
-    config;
-    ruvbot = null;
-    // Guidance components (injected)
-    gates = null;
-    manifestValidator = null;
-    trustSystem = null;
-    aiDefenceGate = null;
-    memoryAdapter = null;
-    // Session proof chains keyed by sessionId
-    sessionChains = new Map();
-    // Bound event handlers for cleanup
-    boundHandlers = new Map();
-    // Event log for diagnostics
-    eventLog = [];
-    static MAX_EVENT_LOG = 1000;
-    constructor(config = {}) {
-        this.config = {
-            enableAIDefence: config.enableAIDefence ?? true,
-            enableMemoryGovernance: config.enableMemoryGovernance ?? true,
-            enableTrustTracking: config.enableTrustTracking ?? true,
-            enableProofChain: config.enableProofChain ?? true,
-        };
-    }
-    /**
-     * Attach guidance control plane components.
-     *
-     * Accepts either a full GuidanceControlPlane instance (from which
-     * sub-components are extracted) or individual components.
-     */
-    attachGuidance(components) {
-        if (components.gates)
-            this.gates = components.gates;
-        if (components.manifestValidator)
-            this.manifestValidator = components.manifestValidator;
-        if (components.trustSystem)
-            this.trustSystem = components.trustSystem;
-        if (components.aiDefenceGate)
-            this.aiDefenceGate = components.aiDefenceGate;
-        if (components.memoryAdapter)
-            this.memoryAdapter = components.memoryAdapter;
-    }
-    /**
-     * Connect to a ruvbot instance and wire all event handlers.
-     *
-     * This is the primary entry point. Once called, the bridge will
-     * intercept ruvbot events and route them through guidance gates.
-     */
-    connect(ruvbot) {
-        if (this.ruvbot) {
-            this.disconnect();
-        }
-        this.ruvbot = ruvbot;
-        // Wire event handlers
-        this.wireEvent('message', this.handleMessage.bind(this));
-        this.wireEvent('agent:spawn', this.handleAgentSpawn.bind(this));
-        this.wireEvent('session:create', this.handleSessionCreate.bind(this));
-        this.wireEvent('session:end', this.handleSessionEnd.bind(this));
-        this.wireEvent('ready', this.handleReady.bind(this));
-        this.wireEvent('shutdown', this.handleShutdown.bind(this));
-        this.wireEvent('error', this.handleError.bind(this));
-        this.wireEvent('agent:stop', this.handleAgentStop.bind(this));
-    }
-    /**
-     * Disconnect from the ruvbot instance, removing all event handlers.
-     */
-    disconnect() {
-        if (!this.ruvbot)
-            return;
-        for (const [event, handler] of this.boundHandlers) {
-            this.ruvbot.off(event, handler);
-        }
-        this.boundHandlers.clear();
-        this.ruvbot = null;
-    }
-    /**
-     * Evaluate a ruvbot AIDefence result and return a GateResult-compatible
-     * decision. Can be called independently of event wiring.
-     */
-    async evaluateAIDefence(input) {
-        if (!this.aiDefenceGate) {
-            throw new Error('AIDefenceGate not attached. Call attachGuidance({ aiDefenceGate }) first.');
-        }
-        const result = await this.aiDefenceGate.evaluateInput(input);
-        return this.aiDefenceGate.toGateResult(result, 'manual-evaluation');
-    }
-    /**
-     * Get the proof chain for a specific session.
-     */
-    getSessionProofChain(sessionId) {
-        return this.sessionChains.get(sessionId);
-    }
-    /**
-     * Get all active session IDs.
-     */
-    getActiveSessionIds() {
-        return [...this.sessionChains.keys()];
-    }
-    /**
-     * Get the event log for diagnostics.
-     */
-    getEventLog() {
-        return this.eventLog;
-    }
-    /**
-     * Get the current bridge configuration.
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Whether the bridge is currently connected to a ruvbot instance.
-     */
-    get connected() {
-        return this.ruvbot !== null;
-    }
-    // ===== Event Handlers =====
-    /**
-     * Handle `message` events: run content through enforcement gates
-     * and optionally through AIDefence.
-     */
-    async handleMessage(...args) {
-        const data = (args[0] ?? {});
-        const content = String(data['content'] ?? data['text'] ?? '');
-        const sessionId = String(data['sessionId'] ?? 'unknown');
-        const agentId = String(data['agentId'] ?? 'unknown');
-        this.logEvent('message', { sessionId, agentId, contentLength: content.length });
-        const gateResults = [];
-        // Step 1: Run through EnforcementGates (secrets, destructive ops)
-        if (this.gates) {
-            const commandResults = this.gates.evaluateCommand(content);
-            gateResults.push(...commandResults);
-        }
-        // Step 2: Run through AIDefence gate
-        if (this.config.enableAIDefence && this.aiDefenceGate) {
-            try {
-                const defenceResult = await this.aiDefenceGate.evaluateInput(content);
-                const gateResult = this.aiDefenceGate.toGateResult(defenceResult, `message:${sessionId}`);
-                if (gateResult.decision !== 'allow') {
-                    gateResults.push(gateResult);
-                }
-            }
-            catch {
-                // AIDefence unavailable; log but do not block
-            }
-        }
-        // Step 3: Feed outcomes into trust accumulator
-        if (this.config.enableTrustTracking && this.trustSystem) {
-            if (gateResults.length === 0) {
-                this.trustSystem.recordOutcome(agentId, 'allow', `Message passed all gates (session: ${sessionId})`);
-            }
-            else {
-                for (const result of gateResults) {
-                    const outcome = gateDecisionToTrustOutcome(result.decision);
-                    this.trustSystem.recordOutcome(agentId, outcome, `Gate "${result.gateName}" ${result.decision}: ${result.reason}`);
-                }
-            }
-        }
-    }
-    /**
-     * Handle `agent:spawn` events: validate agent manifest.
-     */
-    async handleAgentSpawn(...args) {
-        const data = (args[0] ?? {});
-        const agentId = String(data['agentId'] ?? data['id'] ?? 'unknown');
-        const manifest = data['manifest'];
-        this.logEvent('agent:spawn', { agentId, hasManifest: !!manifest });
-        if (this.manifestValidator && manifest) {
-            const validation = this.manifestValidator.validate(manifest);
-            if (this.config.enableTrustTracking && this.trustSystem) {
-                if (validation.admissionDecision === 'admit') {
-                    this.trustSystem.recordOutcome(agentId, 'allow', `Agent manifest validated: admission=${validation.admissionDecision}, risk=${validation.riskScore}`);
-                }
-                else {
-                    const outcome = validation.admissionDecision === 'reject' ? 'deny' : 'warn';
-                    this.trustSystem.recordOutcome(agentId, outcome, `Agent manifest ${validation.admissionDecision}: risk=${validation.riskScore}, errors=${validation.errors.length}`);
-                }
-            }
-        }
-    }
-    /**
-     * Handle `session:create` events: initialize a proof chain for the session.
-     */
-    async handleSessionCreate(...args) {
-        const data = (args[0] ?? {});
-        const sessionId = String(data['sessionId'] ?? data['id'] ?? `session-${Date.now()}`);
-        this.logEvent('session:create', { sessionId });
-        if (this.config.enableProofChain) {
-            if (!this.config.proofSigningKey) {
-                throw new Error('RuvBotBridgeConfig.proofSigningKey is required when enableProofChain is true');
-            }
-            const { createProofChain } = await import('./proof.js');
-            const chain = createProofChain({ signingKey: this.config.proofSigningKey });
-            this.sessionChains.set(sessionId, chain);
-        }
-    }
-    /**
-     * Handle `session:end` events: finalize the proof chain and persist.
-     */
-    async handleSessionEnd(...args) {
-        const data = (args[0] ?? {});
-        const sessionId = String(data['sessionId'] ?? data['id'] ?? 'unknown');
-        this.logEvent('session:end', { sessionId });
-        if (this.config.enableProofChain) {
-            const chain = this.sessionChains.get(sessionId);
-            if (chain) {
-                // Export the finalized chain for external persistence
-                const _exported = chain.export();
-                // The caller can retrieve this via getSessionProofChain() before
-                // the session is cleaned up, or listen for an event.
-                // Clean up
-                this.sessionChains.delete(sessionId);
-            }
-        }
-    }
-    /**
-     * Handle `ready` events: log bridge activation.
-     */
-    async handleReady(...args) {
-        this.logEvent('ready', {});
-    }
-    /**
-     * Handle `shutdown` events: clean up all session proof chains.
-     */
-    async handleShutdown(...args) {
-        this.logEvent('shutdown', {});
-        this.sessionChains.clear();
-    }
-    /**
-     * Handle `error` events: record a deny outcome in trust tracking.
-     */
-    async handleError(...args) {
-        const data = (args[0] ?? {});
-        const agentId = String(data['agentId'] ?? 'unknown');
-        const errorMessage = String(data['message'] ?? data['error'] ?? 'unknown error');
-        this.logEvent('error', { agentId, error: errorMessage });
-        if (this.config.enableTrustTracking && this.trustSystem) {
-            this.trustSystem.recordOutcome(agentId, 'deny', `Error event: ${errorMessage}`);
-        }
-    }
-    /**
-     * Handle `agent:stop` events: record final trust snapshot.
-     */
-    async handleAgentStop(...args) {
-        const data = (args[0] ?? {});
-        const agentId = String(data['agentId'] ?? data['id'] ?? 'unknown');
-        this.logEvent('agent:stop', { agentId });
-    }
-    // ===== Private Helpers =====
-    wireEvent(event, handler) {
-        this.boundHandlers.set(event, handler);
-        this.ruvbot.on(event, handler);
-    }
-    logEvent(type, data) {
-        const event = {
-            type,
-            timestamp: Date.now(),
-            sessionId: data['sessionId'],
-            agentId: data['agentId'],
-            data,
-        };
-        this.eventLog.push(event);
-        if (this.eventLog.length > RuvBotGuidanceBridge.MAX_EVENT_LOG) {
-            this.eventLog = this.eventLog.slice(-RuvBotGuidanceBridge.MAX_EVENT_LOG);
-        }
-    }
-}
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Map a GateDecision to a GateOutcome for trust accumulation.
- *
- * - 'allow' -> 'allow'
- * - 'block' -> 'deny'
- * - 'require-confirmation' -> 'warn'
- * - 'warn' -> 'warn'
- */
-function gateDecisionToTrustOutcome(decision) {
-    switch (decision) {
-        case 'allow': return 'allow';
-        case 'block': return 'deny';
-        case 'warn': return 'warn';
-        case 'require-confirmation': return 'warn';
-        default: return 'warn';
-    }
-}
-// ============================================================================
-// Factory Functions
-// ============================================================================
-/**
- * Create a fully wired RuvBotGuidanceBridge.
- *
- * Connects the bridge to a ruvbot instance and attaches the guidance
- * control plane components. The bridge immediately begins intercepting
- * ruvbot events.
- *
- * @param ruvbotInstance - A ruvbot instance (from createRuvBot())
- * @param guidancePlane - A GuidanceControlPlane or individual components
- * @param config - Optional bridge configuration
- * @returns The connected RuvBotGuidanceBridge
- */
-export function createRuvBotBridge(ruvbotInstance, guidancePlane, config) {
-    const bridge = new RuvBotGuidanceBridge(config);
-    bridge.attachGuidance(guidancePlane);
-    bridge.connect(ruvbotInstance);
-    return bridge;
-}
-/**
- * Create an AIDefenceGate with optional configuration.
- *
- * The gate lazily initializes the underlying ruvbot AIDefence guard
- * on the first evaluation call.
- *
- * @param config - Optional gate configuration
- * @returns A new AIDefenceGate instance
- */
-export function createAIDefenceGate(config) {
-    return new AIDefenceGate(config);
-}
-/**
- * Create a RuvBotMemoryAdapter with governance components.
- *
- * The adapter wraps ruvbot memory operations with MemoryWriteGate authority
- * checks and CoherenceScheduler tracking.
- *
- * @param memoryGate - The MemoryWriteGate for authority/rate/contradiction checks
- * @param coherenceScheduler - The CoherenceScheduler for drift tracking
- * @returns A new RuvBotMemoryAdapter instance
- */
-export function createRuvBotMemoryAdapter(memoryGate, coherenceScheduler) {
-    return new RuvBotMemoryAdapter(memoryGate, coherenceScheduler);
-}
-//# sourceMappingURL=ruvbot-integration.js.map