@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/domains/bee/bee_rechunk_incremental.js

@@ -0,0 +1,204 @@
+/**
+ * Bee Rechunk Incremental — Delta-first re-chunking on file change
+ *
+ * Enhanced version of rechunkFile() that tries delta update first:
+ * 1. Read file and chunk (same as rechunkFile)
+ * 2. Look up existing chain via reverse index
+ * 3. If chain exists → buildChangedBlocks() to detect delta
+ * 4. If delta applicable → updateChainDelta() (surgical update)
+ * 5. If delta not applicable → createChain() (full fallback)
+ *
+ * Returns extended result with delta metadata (changedBlockIds, deltaApplied).
+ *
+ * Best-effort: returns null on failure (never throws).
+ *
+ * @since v1.21.0 (P34)
+ */
+import * as fs from 'node:fs';
+import { promises as fsp } from 'node:fs';
+import * as path from 'node:path';
+import { buildChangedBlocks } from '../../kernel/blocks/chain.js';
+import { buildChunks, chunksToBlockInputs } from '../../mcp/chunking/chunking.js';
+import { resolveChainManager } from '../../kernel/resolve_deps.js';
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Re-chunk a source file using delta update when possible.
+ *
+ * Tries buildChangedBlocks() + updateChainDelta() first.
+ * Falls back to createChain() on structural change or missing chain.
+ *
+ * Returns null if the file is missing, empty, or unreadable.
+ */
+export function rechunkFileIncremental(basePath, filePath, deps) {
+    try {
+        return doRechunkIncremental(basePath, filePath, deps);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Internal
+// ============================================================================
+function doRechunkIncremental(basePath, filePath, deps) {
+    // 1. Read file
+    let text;
+    try {
+        text = fs.readFileSync(path.resolve(basePath, filePath), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (!text.trim())
+        return null;
+    // 2. Chunk
+    const input = {
+        runId: `rechunk-inc-${Date.now()}`,
+        workspaceRoot: basePath,
+        text,
+        filePath,
+    };
+    const { chunks } = buildChunks(input);
+    if (chunks.length === 0)
+        return null;
+    const newBlocks = chunksToBlockInputs(chunks);
+    // 3. Initialize store
+    const { blockStore: store, chainManager } = resolveChainManager(basePath, deps);
+    // 4. Look up existing chain
+    const existingRootHash = store.getRootHashBySourcePath(filePath);
+    if (existingRootHash) {
+        const oldBlocks = chainManager.getChainBlocks(existingRootHash);
+        if (oldBlocks) {
+            // 5. Try delta
+            const changedBlocks = buildChangedBlocks(oldBlocks, newBlocks);
+            if (changedBlocks !== null) {
+                if (changedBlocks.length === 0) {
+                    // No-op: all blocks identical
+                    return {
+                        filePath,
+                        rootHash: existingRootHash,
+                        blockCount: oldBlocks.length,
+                        storedCount: 0,
+                        skippedCount: oldBlocks.length,
+                        deltaApplied: true,
+                        changedBlockIds: [],
+                        unchangedCount: oldBlocks.length,
+                    };
+                }
+                // Delta update
+                const deltaResult = chainManager.updateChainDelta({
+                    rootHash: existingRootHash,
+                    changedBlocks,
+                });
+                // unchangedCount = total blocks minus the ones we submitted for change
+                const totalBlocks = deltaResult.chain.blocks.length;
+                const actualUnchanged = totalBlocks - changedBlocks.length;
+                return {
+                    filePath,
+                    rootHash: deltaResult.chain.root_hash,
+                    blockCount: totalBlocks,
+                    storedCount: deltaResult.storedCount,
+                    skippedCount: actualUnchanged + deltaResult.unchangedCount,
+                    deltaApplied: true,
+                    changedBlockIds: deltaResult.newBlocks.map(b => b.block_id),
+                    unchangedCount: actualUnchanged,
+                };
+            }
+            // Delta not applicable (structural change) — delete old chain first
+            store.deleteChain(existingRootHash);
+        }
+    }
+    // 6. Full fallback: createChain
+    const result = chainManager.createChain({ sourcePath: filePath, blocks: newBlocks });
+    return {
+        filePath,
+        rootHash: result.chain.root_hash,
+        blockCount: result.blocks.length,
+        storedCount: result.storedCount,
+        skippedCount: result.skippedCount,
+        deltaApplied: false,
+        changedBlockIds: result.blocks.map(b => b.block_id),
+        unchangedCount: 0,
+    };
+}
+export async function rechunkFileIncrementalAsync(basePath, filePath, deps) {
+    try {
+        return await doRechunkIncrementalAsync(basePath, filePath, deps);
+    }
+    catch {
+        return null;
+    }
+}
+async function doRechunkIncrementalAsync(basePath, filePath, deps) {
+    let text;
+    try {
+        text = await fsp.readFile(path.resolve(basePath, filePath), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (!text.trim())
+        return null;
+    const input = {
+        runId: `rechunk-inc-${Date.now()}`,
+        workspaceRoot: basePath,
+        text,
+        filePath,
+    };
+    const { chunks } = buildChunks(input);
+    if (chunks.length === 0)
+        return null;
+    const newBlocks = chunksToBlockInputs(chunks);
+    const { blockStore: store, chainManager } = resolveChainManager(basePath, deps);
+    const existingRootHash = store.getRootHashBySourcePath(filePath);
+    if (existingRootHash) {
+        const oldBlocks = chainManager.getChainBlocks(existingRootHash);
+        if (oldBlocks) {
+            const changedBlocks = buildChangedBlocks(oldBlocks, newBlocks);
+            if (changedBlocks !== null) {
+                if (changedBlocks.length === 0) {
+                    return {
+                        filePath,
+                        rootHash: existingRootHash,
+                        blockCount: oldBlocks.length,
+                        storedCount: 0,
+                        skippedCount: oldBlocks.length,
+                        deltaApplied: true,
+                        changedBlockIds: [],
+                        unchangedCount: oldBlocks.length,
+                    };
+                }
+                const deltaResult = chainManager.updateChainDelta({
+                    rootHash: existingRootHash,
+                    changedBlocks,
+                });
+                const totalBlocks = deltaResult.chain.blocks.length;
+                const actualUnchanged = totalBlocks - changedBlocks.length;
+                return {
+                    filePath,
+                    rootHash: deltaResult.chain.root_hash,
+                    blockCount: totalBlocks,
+                    storedCount: deltaResult.storedCount,
+                    skippedCount: actualUnchanged + deltaResult.unchangedCount,
+                    deltaApplied: true,
+                    changedBlockIds: deltaResult.newBlocks.map(b => b.block_id),
+                    unchangedCount: actualUnchanged,
+                };
+            }
+            store.deleteChain(existingRootHash);
+        }
+    }
+    const result = chainManager.createChain({ sourcePath: filePath, blocks: newBlocks });
+    return {
+        filePath,
+        rootHash: result.chain.root_hash,
+        blockCount: result.blocks.length,
+        storedCount: result.storedCount,
+        skippedCount: result.skippedCount,
+        deltaApplied: false,
+        changedBlockIds: result.blocks.map(b => b.block_id),
+        unchangedCount: 0,
+    };
+}

package/build/domains/bee/bee_stream_listener.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Bee Stream Listener — Real-time stderr capture with IPC broadcast
+ *
+ * Hooks into process.stderr.write (tee pattern) to capture diagnostic
+ * log lines without preventing original output. Captured lines are
+ * broadcast to external monitors via IPC (Named Pipe / UDS).
+ *
+ * Error patterns are detected, classified, and tracked for deduplication.
+ *
+ * CRITICAL: stdout is NOT touched — it carries MCP JSON-RPC protocol.
+ * Only stderr is captured (all codebase diagnostics use console.error).
+ *
+ * FAIL-SAFE: Capture errors never prevent original stderr output.
+ * If IPC server fails, the listener still captures and tracks patterns.
+ *
+ * @since v1.13.0
+ */
+import { type LogPattern, type StackFrame } from './log_pattern_registry.js';
+export interface BeeStreamListenerConfig {
+    /** Override IPC pipe path */
+    pipePath?: string;
+    /** Called when an error pattern is detected. Sync, fire-and-forget. */
+    onErrorDetected?: (pattern: LogPattern, stackFrame: StackFrame | null) => void;
+}
+export interface BeeStreamListenerStatus {
+    /** Whether the listener is actively capturing */
+    listening: boolean;
+    /** Total stderr lines captured */
+    linesCaptured: number;
+    /** Number of error lines detected */
+    errorsDetected: number;
+    /** Number of unique error patterns seen */
+    uniquePatterns: number;
+    /** Number of connected IPC clients */
+    clientCount: number;
+    /** IPC pipe path */
+    pipePath: string;
+}
+export interface BeeStreamListenerHandle {
+    /** Stop listening and restore stderr. Shuts down IPC server. */
+    stop(): Promise<void>;
+    /** Get current listener status */
+    status(): BeeStreamListenerStatus;
+}
+/**
+ * Check if BeeStreamListener is enabled via environment variable.
+ */
+export declare function isBeeStreamListenerEnabled(): boolean;
+/**
+ * Start the Bee Stream Listener.
+ *
+ * Hooks process.stderr.write with a tee pattern:
+ * 1. Original write always executes first (output guaranteed)
+ * 2. Copy of data goes to line buffer for processing
+ * 3. Complete lines are broadcast via IPC and analyzed for errors
+ *
+ * Returns a handle with stop() and status() methods.
+ * Returns null if disabled or on startup failure.
+ *
+ * Never throws — returns null on any startup error.
+ */
+export declare function startBeeStreamListener(basePath: string, config?: BeeStreamListenerConfig): BeeStreamListenerHandle | null;

package/build/domains/bee/bee_stream_listener.js

@@ -0,0 +1,161 @@
+/**
+ * Bee Stream Listener — Real-time stderr capture with IPC broadcast
+ *
+ * Hooks into process.stderr.write (tee pattern) to capture diagnostic
+ * log lines without preventing original output. Captured lines are
+ * broadcast to external monitors via IPC (Named Pipe / UDS).
+ *
+ * Error patterns are detected, classified, and tracked for deduplication.
+ *
+ * CRITICAL: stdout is NOT touched — it carries MCP JSON-RPC protocol.
+ * Only stderr is captured (all codebase diagnostics use console.error).
+ *
+ * FAIL-SAFE: Capture errors never prevent original stderr output.
+ * If IPC server fails, the listener still captures and tracks patterns.
+ *
+ * @since v1.13.0
+ */
+import { createIPCServer } from './bee_ipc_server.js';
+import { isErrorLine, classifyError, parseStackFrame, LogPatternRegistry, } from './log_pattern_registry.js';
+// ============================================================================
+// Enable Check
+// ============================================================================
+/**
+ * Check if BeeStreamListener is enabled via environment variable.
+ */
+export function isBeeStreamListenerEnabled() {
+    return process.env.VIBE_BEE_STREAM === '1';
+}
+// ============================================================================
+// Stream Listener
+// ============================================================================
+/**
+ * Start the Bee Stream Listener.
+ *
+ * Hooks process.stderr.write with a tee pattern:
+ * 1. Original write always executes first (output guaranteed)
+ * 2. Copy of data goes to line buffer for processing
+ * 3. Complete lines are broadcast via IPC and analyzed for errors
+ *
+ * Returns a handle with stop() and status() methods.
+ * Returns null if disabled or on startup failure.
+ *
+ * Never throws — returns null on any startup error.
+ */
+export function startBeeStreamListener(basePath, config = {}) {
+    if (!isBeeStreamListenerEnabled())
+        return null;
+    try {
+        return createListener(basePath, config);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Internal Listener
+// ============================================================================
+function createListener(_basePath, config) {
+    // Start IPC server
+    const ipc = createIPCServer({ pipePath: config.pipePath });
+    const registry = new LogPatternRegistry();
+    // State
+    let listening = true;
+    let linesCaptured = 0;
+    let errorsDetected = 0;
+    let lineBuffer = '';
+    // Save original stderr.write for restoration
+    const originalWrite = process.stderr.write;
+    // Tee pattern: intercept stderr without preventing output
+    const hookedWrite = function (chunk, encodingOrCallback, callback) {
+        // ALWAYS pass through to original first (output guaranteed)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        const result = originalWrite.call(process.stderr, chunk, encodingOrCallback, callback);
+        // Process captured data (best-effort, never blocks original)
+        try {
+            if (!listening)
+                return result;
+            const text = typeof chunk === 'string' ? chunk : chunk.toString();
+            lineBuffer += text;
+            // Extract complete lines
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop() ?? ''; // Keep incomplete last line in buffer
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                linesCaptured++;
+                if (processLine(trimmed, ipc, registry, config.onErrorDetected)) {
+                    errorsDetected++;
+                }
+            }
+        }
+        catch {
+            // FAIL-SAFE: capture error never prevents stderr output
+        }
+        return result;
+    };
+    // Apply hook
+    process.stderr.write = hookedWrite;
+    return {
+        async stop() {
+            listening = false;
+            // Restore original stderr.write
+            process.stderr.write = originalWrite;
+            // Shutdown IPC server
+            await ipc.shutdown();
+        },
+        status() {
+            return {
+                listening,
+                linesCaptured,
+                errorsDetected,
+                uniquePatterns: registry.size(),
+                clientCount: ipc.clientCount(),
+                pipePath: ipc.pipePath(),
+            };
+        },
+    };
+}
+// ============================================================================
+// Line Processing
+// ============================================================================
+function processLine(line, ipc, registry, onErrorDetected) {
+    // Broadcast raw line to all monitors
+    const lineMsg = {
+        type: 'STDERR_LINE',
+        timestamp: new Date().toISOString(),
+        data: { line },
+    };
+    ipc.broadcast(lineMsg);
+    // Check for error patterns
+    if (isErrorLine(line)) {
+        const classification = classifyError(line);
+        const stackFrame = parseStackFrame(line);
+        // Track in registry
+        const pattern = registry.record(line, classification);
+        // Broadcast error detection
+        const errorMsg = {
+            type: 'ERROR_DETECTED',
+            timestamp: new Date().toISOString(),
+            data: {
+                line,
+                classification,
+                stackFrame: stackFrame ?? undefined,
+                isNew: !registry.isKnown(line), // After record, isKnown is always true
+            },
+        };
+        ipc.broadcast(errorMsg);
+        // Notify bridge (FAIL-SAFE)
+        if (onErrorDetected) {
+            try {
+                onErrorDetected(pattern, stackFrame);
+            }
+            catch {
+                /* never crash */
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/build/domains/bee/bee_swarm_bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Bee Swarm Bridge — Automatic Swarm triggering for Bee
+ *
+ * When Bee detects high-risk findings with sufficient confidence,
+ * it automatically triggers a Blue/Red Swarm evaluation for deeper analysis.
+ *
+ * FAIL-SAFE: Never throws. Returns BeeSwarmResult with skipReason on failure.
+ * PRO-ONLY: Skips with skipReason when not PRO or inference unavailable.
+ *
+ * Pattern: follows production_bridge.ts FAIL-SAFE approach.
+ *
+ * @since v1.12.0
+ */
+import type { BeeSwarmInput, BeeSwarmResult, BeeSwarmThresholds } from './bee_types.js';
+/**
+ * Trigger a Blue/Red Swarm evaluation based on Bee analysis results.
+ *
+ * Gate checks (all must pass):
+ * 1. PRO tier (BEE_FEATURES.SWARM_AUTO_TRIGGER)
+ * 2. Inference binary available
+ * 3. Risk level meets threshold
+ * 4. Confidence meets threshold
+ * 5. Has target files
+ *
+ * Never throws — returns BeeSwarmResult with skip/error details.
+ */
+export declare function triggerBeeSwarm(input: BeeSwarmInput, thresholds?: BeeSwarmThresholds): Promise<BeeSwarmResult>;
+/**
+ * Check if Swarm should be triggered (boolean convenience).
+ * Useful for pre-check without actually dispatching.
+ */
+export declare function shouldTriggerSwarm(riskLevel: 'low' | 'medium' | 'high', confidence: number, thresholds?: BeeSwarmThresholds): boolean;

package/build/domains/bee/bee_swarm_bridge.js

@@ -0,0 +1,120 @@
+/**
+ * Bee Swarm Bridge — Automatic Swarm triggering for Bee
+ *
+ * When Bee detects high-risk findings with sufficient confidence,
+ * it automatically triggers a Blue/Red Swarm evaluation for deeper analysis.
+ *
+ * FAIL-SAFE: Never throws. Returns BeeSwarmResult with skipReason on failure.
+ * PRO-ONLY: Skips with skipReason when not PRO or inference unavailable.
+ *
+ * Pattern: follows production_bridge.ts FAIL-SAFE approach.
+ *
+ * @since v1.12.0
+ */
+import { getFeatureGate, BEE_FEATURES } from '../../tier/feature_gate.js';
+import { createInferenceFn, isInferenceAvailable } from '../../tier/inference_factory.js';
+import { createSwarmDispatcher } from '../swarm/swarm_dispatcher.js';
+import { DEFAULT_BEE_SWARM_THRESHOLDS } from './bee_types.js';
+// ============================================================================
+// Risk Level Ordering
+// ============================================================================
+const RISK_ORDER = {
+    low: 0,
+    medium: 1,
+    high: 2,
+};
+// ============================================================================
+// Swarm Bridge
+// ============================================================================
+/**
+ * Trigger a Blue/Red Swarm evaluation based on Bee analysis results.
+ *
+ * Gate checks (all must pass):
+ * 1. PRO tier (BEE_FEATURES.SWARM_AUTO_TRIGGER)
+ * 2. Inference binary available
+ * 3. Risk level meets threshold
+ * 4. Confidence meets threshold
+ * 5. Has target files
+ *
+ * Never throws — returns BeeSwarmResult with skip/error details.
+ */
+export async function triggerBeeSwarm(input, thresholds = DEFAULT_BEE_SWARM_THRESHOLDS) {
+    try {
+        // ---- Gate checks ----
+        const skipReason = checkBeeSwarmGates(input, thresholds);
+        if (skipReason) {
+            return { triggered: false, skipReason };
+        }
+        // ---- Dispatch Swarm ----
+        const inferFn = createInferenceFn();
+        const dispatcher = createSwarmDispatcher(inferFn);
+        const blastInfo = input.enrichment
+            ? ` Blast radius: ${input.enrichment.blast_radius_count} file(s).`
+            : '';
+        const swarmRequest = {
+            files: input.targetFiles,
+            context: input.analysisContext,
+            patchDescription: `Bee detected ${input.riskLevel} risk (confidence: ${input.confidence}).${blastInfo}`,
+            reason: `Bee auto-trigger: ${input.riskLevel} risk on ${input.targetFiles.length} file(s)`,
+        };
+        const consensus = await dispatcher.dispatch(swarmRequest);
+        return {
+            triggered: true,
+            verdict: consensus.verdict,
+            riskScore: consensus.riskScore,
+        };
+    }
+    catch (e) {
+        return {
+            triggered: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+// ============================================================================
+// Gate Checks
+// ============================================================================
+/**
+ * Check preconditions for Bee Swarm triggering.
+ * Returns skip reason string or null if all gates pass.
+ */
+function checkBeeSwarmGates(input, thresholds) {
+    // 1. PRO tier required (SWARM_AUTO_TRIGGER gate)
+    try {
+        const gate = getFeatureGate();
+        if (!gate.isAllowed(BEE_FEATURES.SWARM_AUTO_TRIGGER)) {
+            return 'PRO_REQUIRED';
+        }
+    }
+    catch {
+        return 'GATE_ERROR';
+    }
+    // 2. Inference binary must be available
+    if (!isInferenceAvailable()) {
+        return 'NO_INFERENCE';
+    }
+    // 3. Risk level must meet threshold
+    const inputRisk = RISK_ORDER[input.riskLevel] ?? 0;
+    const thresholdRisk = RISK_ORDER[thresholds.riskLevel] ?? 2;
+    if (inputRisk < thresholdRisk) {
+        return `RISK_TOO_LOW: ${input.riskLevel} < ${thresholds.riskLevel}`;
+    }
+    // 4. Confidence must meet threshold
+    if (input.confidence < thresholds.confidenceMin) {
+        return `CONFIDENCE_TOO_LOW: ${input.confidence} < ${thresholds.confidenceMin}`;
+    }
+    // 5. Must have target files
+    if (!input.targetFiles || input.targetFiles.length === 0) {
+        return 'NO_FILES';
+    }
+    return null;
+}
+/**
+ * Check if Swarm should be triggered (boolean convenience).
+ * Useful for pre-check without actually dispatching.
+ */
+export function shouldTriggerSwarm(riskLevel, confidence, thresholds = DEFAULT_BEE_SWARM_THRESHOLDS) {
+    const inputRisk = RISK_ORDER[riskLevel] ?? 0;
+    const thresholdRisk = RISK_ORDER[thresholds.riskLevel] ?? 2;
+    return inputRisk >= thresholdRisk && confidence >= thresholds.confidenceMin;
+}

package/build/domains/bee/bee_triangulation.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Bee Triangulation — Intent Inference + Signal Alignment
+ *
+ * Infers developer intent from file change patterns and cross-validates
+ * against the active trigger rule. Adjusts confidence and risk based on
+ * alignment between inferred intent and observed behavior.
+ *
+ * Two-axis model:
+ * - Top-Down (Intent): What the developer is TRYING to do (inferred from file paths)
+ * - Bottom-Up (Behavior): What's actually HAPPENING (trigger, errors, dependencies)
+ *
+ * Pure functions — no side effects, no external dependencies.
+ *
+ * @since v1.22.0 (P31)
+ */
+export type InferredIntent = 'AUTH_WORK' | 'TEST_WORK' | 'DEP_MANAGEMENT' | 'CONFIG_CHANGE' | 'FEATURE_WORK' | 'BUG_FIX' | 'UNKNOWN';
+export type AlignmentLevel = 'ALIGNED' | 'PARTIAL' | 'MISALIGNED' | 'UNKNOWN';
+export interface TriangulationInput {
+    /** Changed file paths (workspace-relative) */
+    changedPaths: string[];
+    /** Active trigger rule ID (e.g. 'T3_AUTH_TOUCH') */
+    triggerId: string;
+    /** Risk level from heuristic analysis */
+    heuristicRiskLevel?: 'low' | 'medium' | 'high';
+    /** Confidence from heuristic analysis (0.0~1.0) */
+    heuristicConfidence?: number;
+    /** Number of errors detected by BeeStreamListener */
+    errorsDetected?: number;
+    /** Blast radius from dependency graph */
+    blastRadiusCount?: number;
+}
+export interface TriangulationResult {
+    /** Inferred intent from file paths */
+    inferredIntent: InferredIntent;
+    /** How well the trigger aligns with the observed behavior */
+    alignment: AlignmentLevel;
+    /** Adjusted confidence (boosted if aligned, reduced if misaligned) */
+    adjustedConfidence: number;
+    /** Adjusted risk level */
+    adjustedRisk: 'low' | 'medium' | 'high';
+    /** Human-readable reason */
+    reason: string;
+}
+/**
+ * Infer developer intent from changed file paths.
+ * Priority: AUTH_WORK > TEST_WORK > DEP_MANAGEMENT > CONFIG_CHANGE > FEATURE_WORK
+ */
+export declare function inferIntentFromPaths(changedPaths: string[]): InferredIntent;
+/**
+ * Check how well the inferred intent aligns with the active trigger.
+ */
+export declare function checkTriggerAlignment(intent: InferredIntent, triggerId: string): AlignmentLevel;
+/**
+ * Adjust confidence based on signal alignment and additional signals.
+ */
+export declare function adjustConfidence(base: number, alignment: AlignmentLevel, errorsDetected: number, blastRadiusCount: number): number;
+/**
+ * Adjust risk level based on alignment and error signals.
+ */
+export declare function adjustRisk(base: 'low' | 'medium' | 'high', alignment: AlignmentLevel, errorsDetected: number): 'low' | 'medium' | 'high';
+/**
+ * Perform triangulation: infer intent, check alignment, adjust signals.
+ *
+ * Pure function — no side effects.
+ */
+export declare function triangulate(input: TriangulationInput): TriangulationResult;