@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/{tier → domains/bee}/cooldown_store.js

@@ -7,12 +7,13 @@
  *
  * @since v1.6.0
  */
-import * as fs from "fs";
-import * as path from "path";
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '../../shared/logger.js';
 // ============================================================================
 // Constants
 // ============================================================================
-const COOLDOWN_FILE = "trigger_cooldowns.v1.json";
+const COOLDOWN_FILE = 'trigger_cooldowns.v1.json';
 const COOLDOWN_VERSION = 1;
 // ============================================================================
 // Cooldown Store Class
@@ -22,7 +23,7 @@ export class CooldownStore {
     filePath;
     loaded = false;
     constructor(basePath) {
-        this.filePath = path.join(basePath, ".vibe", "cache", "bitnet", COOLDOWN_FILE);
+        this.filePath = path.join(basePath, '.vibe', 'cache', 'bitnet', COOLDOWN_FILE);
     }
     /**
      * Check if a trigger is currently on cooldown
@@ -103,7 +104,7 @@ export class CooldownStore {
     load() {
         try {
             if (fs.existsSync(this.filePath)) {
-                const raw = fs.readFileSync(this.filePath, "utf-8");
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
                 const data = JSON.parse(raw);
                 if (data.version === COOLDOWN_VERSION && data.records) {
                     this.records = new Map(Object.entries(data.records));
@@ -125,12 +126,12 @@ export class CooldownStore {
                 records: Object.fromEntries(this.records),
                 version: COOLDOWN_VERSION,
             };
-            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
         }
         catch (err) {
             // Log but don't throw - cooldown is not critical
-            if (process.env.VIBECODE_DEBUG === "1") {
-                console.error(`[cooldown] Failed to save: ${err}`);
+            if (process.env.VIBECODE_DEBUG === '1') {
+                logger.error(`[cooldown] Failed to save: ${err}`);
             }
         }
     }

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

@@ -0,0 +1,69 @@
+/**
+ * File Hash Registry — Incremental change detection for Bee pipeline
+ *
+ * Tracks file content hashes to avoid redundant analysis.
+ * Uses mtime as fast pre-check, SHA-256 as authoritative hash.
+ *
+ * Pattern: same as CooldownStore (file-based JSON, lazy load, FAIL-SAFE).
+ * Inspired by "Compare documents early, chunk later" (Smarter RAG Indexing).
+ *
+ * @since v1.13.0
+ */
+export interface FileHashEntry {
+    /** SHA-256 hex of file content */
+    hash: string;
+    /** File modification time (ms) */
+    mtime: number;
+    /** File size in bytes */
+    size: number;
+    /** When this file was last analyzed (epoch ms) */
+    last_analyzed: number;
+}
+export type FileCheckResult = 'add' | 'skip' | 'update';
+export declare class FileHashRegistry {
+    private entries;
+    private filePath;
+    private basePath;
+    private loaded;
+    constructor(basePath: string);
+    /**
+     * Check a single file: 'add' (new), 'skip' (unchanged), 'update' (changed).
+     *
+     * Fast path: mtime + size match → skip (no hash computation).
+     * Slow path: mtime/size differ → compute SHA-256, compare hash.
+     */
+    checkFile(filePath: string): FileCheckResult;
+    /**
+     * Filter a list of file paths, returning only add/update files.
+     */
+    getChangedFiles(filePaths: string[]): string[];
+    /**
+     * Record that a file was analyzed. Updates hash, mtime, size, timestamp.
+     */
+    recordAnalyzed(filePath: string): void;
+    /**
+     * Record multiple files as analyzed.
+     */
+    recordAllAnalyzed(filePaths: string[]): void;
+    /**
+     * Get the stored entry for a file (for diagnostics).
+     */
+    getEntry(filePath: string): FileHashEntry | undefined;
+    /**
+     * Get total number of tracked files.
+     */
+    get size(): number;
+    /**
+     * Remove entries for files that no longer exist on disk.
+     * Returns count of removed entries.
+     */
+    cleanup(): number;
+    /**
+     * Clear all entries.
+     */
+    clear(): void;
+    private ensureLoaded;
+    private load;
+    private save;
+    private computeFileHash;
+}

package/build/domains/bee/file_hash_registry.js

@@ -0,0 +1,189 @@
+/**
+ * File Hash Registry — Incremental change detection for Bee pipeline
+ *
+ * Tracks file content hashes to avoid redundant analysis.
+ * Uses mtime as fast pre-check, SHA-256 as authoritative hash.
+ *
+ * Pattern: same as CooldownStore (file-based JSON, lazy load, FAIL-SAFE).
+ * Inspired by "Compare documents early, chunk later" (Smarter RAG Indexing).
+ *
+ * @since v1.13.0
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+// ============================================================================
+// Constants
+// ============================================================================
+const REGISTRY_FILE = 'file_hashes.v1.json';
+const REGISTRY_VERSION = 1;
+// ============================================================================
+// FileHashRegistry
+// ============================================================================
+export class FileHashRegistry {
+    entries = new Map();
+    filePath;
+    basePath;
+    loaded = false;
+    constructor(basePath) {
+        this.basePath = basePath;
+        this.filePath = path.join(basePath, '.vibe', 'cache', 'bitnet', REGISTRY_FILE);
+    }
+    /**
+     * Check a single file: 'add' (new), 'skip' (unchanged), 'update' (changed).
+     *
+     * Fast path: mtime + size match → skip (no hash computation).
+     * Slow path: mtime/size differ → compute SHA-256, compare hash.
+     */
+    checkFile(filePath) {
+        this.ensureLoaded();
+        const absPath = path.resolve(this.basePath, filePath);
+        let stat;
+        try {
+            stat = fs.statSync(absPath);
+        }
+        catch {
+            return 'add'; // File doesn't exist or unreadable — treat as new
+        }
+        const existing = this.entries.get(filePath);
+        // No previous record → add
+        if (!existing)
+            return 'add';
+        // Fast path: mtime + size match → skip
+        if (existing.mtime === stat.mtimeMs && existing.size === stat.size) {
+            return 'skip';
+        }
+        // Slow path: compute hash
+        const newHash = this.computeFileHash(absPath);
+        if (!newHash)
+            return 'update'; // Can't read → treat as changed
+        return newHash === existing.hash ? 'skip' : 'update';
+    }
+    /**
+     * Filter a list of file paths, returning only add/update files.
+     */
+    getChangedFiles(filePaths) {
+        return filePaths.filter(fp => {
+            const result = this.checkFile(fp);
+            return result === 'add' || result === 'update';
+        });
+    }
+    /**
+     * Record that a file was analyzed. Updates hash, mtime, size, timestamp.
+     */
+    recordAnalyzed(filePath) {
+        this.ensureLoaded();
+        const absPath = path.resolve(this.basePath, filePath);
+        try {
+            const stat = fs.statSync(absPath);
+            const hash = this.computeFileHash(absPath);
+            if (!hash)
+                return;
+            this.entries.set(filePath, {
+                hash,
+                mtime: stat.mtimeMs,
+                size: stat.size,
+                last_analyzed: Date.now(),
+            });
+        }
+        catch {
+            // Best-effort: can't stat/read → skip recording
+        }
+    }
+    /**
+     * Record multiple files as analyzed.
+     */
+    recordAllAnalyzed(filePaths) {
+        for (const fp of filePaths) {
+            this.recordAnalyzed(fp);
+        }
+        this.save();
+    }
+    /**
+     * Get the stored entry for a file (for diagnostics).
+     */
+    getEntry(filePath) {
+        this.ensureLoaded();
+        return this.entries.get(filePath);
+    }
+    /**
+     * Get total number of tracked files.
+     */
+    get size() {
+        this.ensureLoaded();
+        return this.entries.size;
+    }
+    /**
+     * Remove entries for files that no longer exist on disk.
+     * Returns count of removed entries.
+     */
+    cleanup() {
+        this.ensureLoaded();
+        let removed = 0;
+        for (const [filePath] of this.entries) {
+            const absPath = path.resolve(this.basePath, filePath);
+            if (!fs.existsSync(absPath)) {
+                this.entries.delete(filePath);
+                removed++;
+            }
+        }
+        if (removed > 0)
+            this.save();
+        return removed;
+    }
+    /**
+     * Clear all entries.
+     */
+    clear() {
+        this.entries.clear();
+        this.save();
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.load();
+        this.loaded = true;
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                const data = JSON.parse(raw);
+                if (data.version === REGISTRY_VERSION && data.entries) {
+                    this.entries = new Map(Object.entries(data.entries));
+                }
+            }
+        }
+        catch {
+            this.entries = new Map();
+        }
+    }
+    save() {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const data = {
+                version: REGISTRY_VERSION,
+                entries: Object.fromEntries(this.entries),
+            };
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch {
+            // FAIL-SAFE: registry is not critical
+        }
+    }
+    computeFileHash(absPath) {
+        try {
+            const content = fs.readFileSync(absPath, 'utf-8');
+            return crypto.createHash('sha256').update(content).digest('hex');
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Bee Domain — Barrel Export
+ *
+ * Aggregates all Bee domain modules: orchestrator, watcher, stream listener,
+ * import parser, context enricher, chain storage, IPC, and support files.
+ *
+ * @since v1.18.0
+ */
+export type { DependencyGraph, DependencyGraphSnapshot, ParsedImport, BeeEnrichment, BeeSwarmInput, BeeSwarmResult, BeeOrchestratorResult, BeeSwarmThresholds, } from './bee_types.js';
+export { DEFAULT_BEE_SWARM_THRESHOLDS } from './bee_types.js';
+export { stripCommentsAndStrings, parseImports, resolveSpecifier, buildDependencyGraph, getForwardDeps, getReverseDeps, computeBlastRadius, snapshotGraph, } from './bee_import_parser.js';
+export { triggerBeeSwarm, shouldTriggerSwarm } from './bee_swarm_bridge.js';
+export { runBeeAnalysis, createBeeRunner } from './bee_orchestrator.js';
+export { enrichDependencyContext, formatEnrichedContext } from './bee_context_enricher.js';
+export type { ConcentratedFile, BeeEnrichedContext } from './bee_context_enricher.js';
+export { writeBeeResultToChain, readBeeChainMeta } from './bee_chain_storage.js';
+export type { BeeChainResult, BeeChainInput } from './bee_chain_storage.js';
+export { startBeeWatcher, isBeeWatcherEnabled } from './bee_watcher.js';
+export type { BeeWatcherConfig, BeeWatcherStatus, BeeWatcherHandle } from './bee_watcher.js';
+export { FileHashRegistry } from './file_hash_registry.js';
+export type { FileHashEntry, FileCheckResult } from './file_hash_registry.js';
+export { createIPCServer, getDefaultPipePath } from './bee_ipc_server.js';
+export type { IPCMessage, IPCInboundMessage, IPCServerConfig, IPCServerHandle, } from './bee_ipc_server.js';
+export { LogPatternRegistry, isErrorLine, classifyError, parseStackFrame, } from './log_pattern_registry.js';
+export type { ErrorClassification, StackFrame, LogPattern } from './log_pattern_registry.js';
+export { startBeeStreamListener, isBeeStreamListenerEnabled } from './bee_stream_listener.js';
+export type { BeeStreamListenerHandle, BeeStreamListenerConfig, BeeStreamListenerStatus, } from './bee_stream_listener.js';
+export type { TriggerRuleId, TriggerRule, TriggerFacts, RepoFacts, RiskFacts, EngineFacts, GateFacts, ScoutFacts, TriggerEvaluationResult, ScoutRunResult, TriggerStatus, } from './trigger_types.js';
+export { CooldownStore } from './cooldown_store.js';
+export { collectTriggerFacts, recordDailySweep, saveLatestVerdict, } from './trigger_facts_collector.js';
+export { TriggerEvaluator, createTriggerEvaluator, TRIGGER_RULES } from './trigger_evaluator.js';
+export { ScoutRunner, createScoutRunner } from './scout_runner.js';
+export { analyzeAuthTouch, analyzeGateViolation, analyzeDepShift } from './scout_heuristics.js';
+export type { AuthTouchContext, GateFixContext, DepShiftContext } from './scout_heuristics.js';
+export { writeScoutResultToChain } from './scout_chain_storage.js';
+export type { ScoutChainResult } from './scout_chain_storage.js';

package/build/domains/bee/index.js

@@ -0,0 +1,37 @@
+/**
+ * Bee Domain — Barrel Export
+ *
+ * Aggregates all Bee domain modules: orchestrator, watcher, stream listener,
+ * import parser, context enricher, chain storage, IPC, and support files.
+ *
+ * @since v1.18.0
+ */
+export { DEFAULT_BEE_SWARM_THRESHOLDS } from './bee_types.js';
+// Bee Import Parser (P11)
+export { stripCommentsAndStrings, parseImports, resolveSpecifier, buildDependencyGraph, getForwardDeps, getReverseDeps, computeBlastRadius, snapshotGraph, } from './bee_import_parser.js';
+// Bee Swarm Bridge (P11)
+export { triggerBeeSwarm, shouldTriggerSwarm } from './bee_swarm_bridge.js';
+// Bee Orchestrator (P11)
+export { runBeeAnalysis, createBeeRunner } from './bee_orchestrator.js';
+// Bee Context Enricher (P11b)
+export { enrichDependencyContext, formatEnrichedContext } from './bee_context_enricher.js';
+// Bee Chain Storage (P11b)
+export { writeBeeResultToChain, readBeeChainMeta } from './bee_chain_storage.js';
+// Bee Watcher (P11c)
+export { startBeeWatcher, isBeeWatcherEnabled } from './bee_watcher.js';
+// File Hash Registry (P12)
+export { FileHashRegistry } from './file_hash_registry.js';
+// Bee IPC Server (P12.5 + P12.8a)
+export { createIPCServer, getDefaultPipePath } from './bee_ipc_server.js';
+// Log Pattern Registry (P12.5)
+export { LogPatternRegistry, isErrorLine, classifyError, parseStackFrame, } from './log_pattern_registry.js';
+// Bee Stream Listener (P12.5)
+export { startBeeStreamListener, isBeeStreamListenerEnabled } from './bee_stream_listener.js';
+export { CooldownStore } from './cooldown_store.js';
+export { collectTriggerFacts, recordDailySweep, saveLatestVerdict, } from './trigger_facts_collector.js';
+export { TriggerEvaluator, createTriggerEvaluator, TRIGGER_RULES } from './trigger_evaluator.js';
+export { ScoutRunner, createScoutRunner } from './scout_runner.js';
+// Scout Heuristics
+export { analyzeAuthTouch, analyzeGateViolation, analyzeDepShift } from './scout_heuristics.js';
+// Scout Chain Storage
+export { writeScoutResultToChain } from './scout_chain_storage.js';

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

@@ -0,0 +1,81 @@
+/**
+ * Intent Tracker — IPC intent injection + serial reasoning trigger
+ *
+ * Receives external intent via IPC, stores in L2 memory (in-process buffer),
+ * and triggers runSerialChain() for multi-step reasoning.
+ *
+ * Part of the triangulation architecture:
+ * - Top-Down: IPC intent injection (this module)
+ * - Bottom-Up: BeeWatcher file changes + BeeStreamListener errors
+ *
+ * FAIL-SAFE: All errors caught and logged, never crash the process.
+ *
+ * @since v1.14.0
+ */
+import type { InferenceFn } from '../swarm/swarm_dispatcher.js';
+import type { TerminationReason } from '../swarm/reasoning_chain.js';
+import type { BlockDeps } from '../../kernel/deps.js';
+export type IntentType = 'FEATURE_WORK' | 'BUG_FIX' | 'SPEC_WORK' | 'REFACTOR' | 'EXPLORATION' | 'UNKNOWN';
+export interface ReceivedIntent {
+    id: string;
+    intentType: IntentType;
+    description: string;
+    source: 'IPC' | 'INTERNAL';
+    receivedAt: number;
+    payload?: unknown;
+}
+export interface IntentTrackerConfig {
+    /** Override IPC pipe path */
+    pipePath?: string;
+    /** Max reasoning steps per intent (default: 5) */
+    maxSteps?: number;
+    /** Token budget per step (default: 2000) */
+    tokenBudget?: number;
+    /** Override inference function (DI for testing) */
+    infer?: InferenceFn;
+    /** Optional injected block dependencies */
+    deps?: BlockDeps;
+}
+export interface IntentTrackerStatus {
+    listening: boolean;
+    intentsReceived: number;
+    pendingCount: number;
+    chainsTriggered: number;
+    lastIntentAt: number | null;
+    ipcClientCount: number;
+}
+export interface IntentRunResult {
+    intent: ReceivedIntent;
+    rootHash: string | null;
+    steps: number;
+    terminationReason: TerminationReason | 'skipped';
+}
+export interface IntentTrackerHandle {
+    stop(): Promise<void>;
+    status(): IntentTrackerStatus;
+    inject(intent: ReceivedIntent): void;
+    getIntents(): ReceivedIntent[];
+    getCurrentIntent(): ReceivedIntent | null;
+}
+/**
+ * Classify an IPC payload into an IntentType.
+ * FAIL-SAFE: returns 'UNKNOWN' for any invalid input.
+ */
+export declare function classifyIntent(payload: unknown): IntentType;
+/**
+ * Format a ReceivedIntent into initial context text for runSerialChain.
+ */
+export declare function formatIntentContext(intent: ReceivedIntent): string;
+/**
+ * Check if IntentTracker is enabled via environment variable.
+ */
+export declare function isIntentTrackerEnabled(): boolean;
+/**
+ * Start the IntentTracker.
+ *
+ * Creates an IPC server, listens for INTENT_INJECTION messages,
+ * stores intents in L2 memory, and triggers serial reasoning chains.
+ *
+ * Returns null if disabled or on startup error (FAIL-SAFE).
+ */
+export declare function startIntentTracker(basePath: string, config?: IntentTrackerConfig): IntentTrackerHandle | null;

package/build/domains/bee/intent_tracker.js

@@ -0,0 +1,185 @@
+/**
+ * Intent Tracker — IPC intent injection + serial reasoning trigger
+ *
+ * Receives external intent via IPC, stores in L2 memory (in-process buffer),
+ * and triggers runSerialChain() for multi-step reasoning.
+ *
+ * Part of the triangulation architecture:
+ * - Top-Down: IPC intent injection (this module)
+ * - Bottom-Up: BeeWatcher file changes + BeeStreamListener errors
+ *
+ * FAIL-SAFE: All errors caught and logged, never crash the process.
+ *
+ * @since v1.14.0
+ */
+import { createIPCServer, getDefaultPipePath } from './bee_ipc_server.js';
+import { runSerialChain } from '../swarm/reasoning_chain.js';
+import { createInferenceFn, isInferenceAvailable } from '../../tier/inference_factory.js';
+import { ContextAssembler } from '../../kernel/blocks/assembler.js';
+import { resolveChainManager } from '../../kernel/resolve_deps.js';
+const VALID_INTENT_TYPES = new Set([
+    'FEATURE_WORK',
+    'BUG_FIX',
+    'SPEC_WORK',
+    'REFACTOR',
+    'EXPLORATION',
+]);
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Classify an IPC payload into an IntentType.
+ * FAIL-SAFE: returns 'UNKNOWN' for any invalid input.
+ */
+export function classifyIntent(payload) {
+    if (!payload || typeof payload !== 'object')
+        return 'UNKNOWN';
+    const p = payload;
+    const intent = p.intent;
+    if (typeof intent === 'string' && VALID_INTENT_TYPES.has(intent)) {
+        return intent;
+    }
+    return 'UNKNOWN';
+}
+/**
+ * Format a ReceivedIntent into initial context text for runSerialChain.
+ */
+export function formatIntentContext(intent) {
+    const ts = new Date(intent.receivedAt).toISOString();
+    return [
+        `Intent: ${intent.intentType}`,
+        `Description: ${intent.description}`,
+        `Source: ${intent.source}`,
+        `Received: ${ts}`,
+        '---',
+        'Analyze the above intent and determine what actions are needed.',
+    ].join('\n');
+}
+// ============================================================================
+// Core
+// ============================================================================
+/**
+ * Check if IntentTracker is enabled via environment variable.
+ */
+export function isIntentTrackerEnabled() {
+    return process.env.VIBE_INTENT_TRACKER === '1';
+}
+/**
+ * Start the IntentTracker.
+ *
+ * Creates an IPC server, listens for INTENT_INJECTION messages,
+ * stores intents in L2 memory, and triggers serial reasoning chains.
+ *
+ * Returns null if disabled or on startup error (FAIL-SAFE).
+ */
+export function startIntentTracker(basePath, config = {}) {
+    if (!isIntentTrackerEnabled())
+        return null;
+    try {
+        return createTracker(basePath, config);
+    }
+    catch {
+        return null;
+    }
+}
+function createTracker(basePath, config) {
+    // L2 state
+    const intents = [];
+    let listening = true;
+    let intentsReceived = 0;
+    let chainsTriggered = 0;
+    let lastIntentAt = null;
+    let seq = 0;
+    const pipePath = config.pipePath ?? getDefaultPipePath() + '-intent';
+    // IPC server with inbound handler
+    const ipc = createIPCServer({
+        pipePath,
+        onMessage: msg => {
+            if (!listening)
+                return;
+            if (msg.type !== 'INTENT_INJECTION')
+                return;
+            try {
+                const intentType = classifyIntent(msg.payload);
+                const p = msg.payload && typeof msg.payload === 'object'
+                    ? msg.payload
+                    : {};
+                const description = typeof p.description === 'string' ? p.description : '(no description)';
+                seq++;
+                const intent = {
+                    id: `intent-${seq}`,
+                    intentType,
+                    description,
+                    source: 'IPC',
+                    receivedAt: Date.now(),
+                    payload: msg.payload,
+                };
+                intentsReceived++;
+                lastIntentAt = intent.receivedAt;
+                intents.push(intent);
+                // Fire-and-forget chain trigger
+                tryTriggerChain(intent).catch(() => {
+                    // FAIL-SAFE: swallow errors
+                });
+            }
+            catch {
+                // FAIL-SAFE: invalid payload structure
+            }
+        },
+    });
+    async function tryTriggerChain(intent) {
+        const infer = config.infer ?? (isInferenceAvailable() ? createInferenceFn() : null);
+        if (!infer) {
+            return { intent, rootHash: null, steps: 0, terminationReason: 'skipped' };
+        }
+        const { blockStore: store, chainManager } = resolveChainManager(basePath, config.deps);
+        const assembler = new ContextAssembler(store);
+        const result = await runSerialChain(`intent:${intent.id}`, formatIntentContext(intent), {
+            infer,
+            chainManager,
+            assembler,
+            maxSteps: config.maxSteps ?? 5,
+            tokenBudget: config.tokenBudget ?? 2000,
+        });
+        chainsTriggered++;
+        return {
+            intent,
+            rootHash: result.rootHash,
+            steps: result.totalSteps,
+            terminationReason: result.terminationReason,
+        };
+    }
+    return {
+        async stop() {
+            listening = false;
+            intents.length = 0;
+            await ipc.shutdown();
+        },
+        status() {
+            return {
+                listening,
+                intentsReceived,
+                pendingCount: intents.length,
+                chainsTriggered,
+                lastIntentAt,
+                ipcClientCount: ipc.clientCount(),
+            };
+        },
+        inject(intent) {
+            if (!listening)
+                return;
+            intentsReceived++;
+            lastIntentAt = intent.receivedAt;
+            intents.push(intent);
+            tryTriggerChain(intent).catch(() => {
+                // FAIL-SAFE
+            });
+        },
+        getIntents() {
+            return [...intents];
+        },
+        getCurrentIntent() {
+            return intents.length > 0 ? intents[intents.length - 1] : null;
+        },
+    };
+}