moflo 4.8.16 → 4.8.17

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

@@ -0,0 +1,738 @@
+/**
+ * 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