byterover-cli 1.0.5 → 1.2.0

package/dist/infra/connectors/shared/template-service.d.ts

@@ -0,0 +1,27 @@
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ConnectorType } from '../../../core/domain/entities/connector-type.js';
+import type { IRuleTemplateService } from '../../../core/interfaces/i-rule-template-service.js';
+import type { ITemplateLoader } from '../../../core/interfaces/i-template-loader.js';
+/**
+ * Service for generating rule templates for different agents.
+ * Loads templates from external files and assembles them with agent-specific context.
+ */
+export declare class RuleTemplateService implements IRuleTemplateService {
+    private readonly templateLoader;
+    constructor(templateLoader: ITemplateLoader);
+    /**
+     * Generates rule content for the specified agent by loading and assembling templates.
+     * @param agent The agent for which to generate rules.
+     * @returns Promise resolving to the rule content as a string.
+     * @throws Error if templates cannot be loaded or assembled.
+     */
+    generateRuleContent(agent: Agent, type?: ConnectorType): Promise<string>;
+    /**
+     * Generates CLI mode content with full workflow and command reference.
+     */
+    private generateCliContent;
+    /**
+     * Generates MCP mode content with concise tool-focused instructions.
+     */
+    private generateMcpContent;
+}

package/dist/infra/connectors/shared/template-service.js

@@ -0,0 +1,125 @@
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from './constants.js';
+/**
+ * Wraps rule content with boundary markers for identification and replacement.
+ *
+ * @param content The rule content to wrap.
+ * @param agent The agent name for the footer tag.
+ * @param header Agent-specific header.
+ * @returns The wrapped content with boundary markers.
+ */
+const wrapContentWithBoundaryMarkers = (content, agent, header) => {
+    const parts = [BRV_RULE_MARKERS.START, header, content, '---', `${BRV_RULE_TAG} ${agent}`, BRV_RULE_MARKERS.END];
+    return parts.join('\n');
+};
+const guideHeaders = [
+    {
+        agent: 'Augment Code',
+        value: `---
+type: "always_apply"
+---`,
+    },
+    {
+        agent: 'Cursor',
+        value: `---
+description: ByteRover CLI Rules
+alwaysApply: true
+---`,
+    },
+    {
+        agent: 'Kiro',
+        value: `---
+inclusion: always
+---`,
+    },
+    {
+        agent: 'Qoder',
+        value: `---
+trigger: always_on
+alwaysApply: true
+---`,
+    },
+    {
+        agent: 'Windsurf',
+        value: `---
+trigger: always_on
+---`,
+    },
+];
+/**
+ * Service for generating rule templates for different agents.
+ * Loads templates from external files and assembles them with agent-specific context.
+ */
+export class RuleTemplateService {
+    templateLoader;
+    constructor(templateLoader) {
+        this.templateLoader = templateLoader;
+    }
+    /**
+     * Generates rule content for the specified agent by loading and assembling templates.
+     * @param agent The agent for which to generate rules.
+     * @returns Promise resolving to the rule content as a string.
+     * @throws Error if templates cannot be loaded or assembled.
+     */
+    async generateRuleContent(agent, type) {
+        try {
+            // Load section templates
+            let content;
+            switch (type) {
+                case 'mcp': {
+                    content = await this.generateMcpContent();
+                    break;
+                }
+                case 'rules': {
+                    content = await this.generateCliContent(agent);
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported connector type: ${type}`);
+                }
+            }
+            // Add agent-specific header if available
+            const header = guideHeaders.find((h) => h.agent === agent)?.value || '';
+            return wrapContentWithBoundaryMarkers(content, agent, header);
+        }
+        catch (error) {
+            throw new Error(`Failed to generate rule content for agent '${agent}' - type '${type}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Generates CLI mode content with full workflow and command reference.
+     */
+    async generateCliContent(agent) {
+        // Load section templates
+        const workflow = await this.templateLoader.loadSection('workflow');
+        const commandReference = await this.templateLoader.loadSection('command-reference');
+        // Load base template
+        const baseTemplate = await this.templateLoader.loadTemplate('base.md');
+        // Assemble context for variable substitution
+        const context = {
+            /* eslint-disable camelcase */
+            agent_name: agent,
+            command_reference: commandReference,
+            workflow,
+            /* eslint-enable camelcase */
+        };
+        // Substitute variables and get content
+        return this.templateLoader.substituteVariables(baseTemplate, context);
+    }
+    /**
+     * Generates MCP mode content with concise tool-focused instructions.
+     */
+    async generateMcpContent() {
+        // Load MCP-specific section
+        const mcpWorkflow = await this.templateLoader.loadSection('mcp-workflow');
+        // Load MCP base template
+        const mcpBaseTemplate = await this.templateLoader.loadTemplate('mcp-base.md');
+        // Assemble context for variable substitution
+        const context = {
+            /* eslint-disable camelcase */
+            mcp_workflow: mcpWorkflow,
+            /* eslint-enable camelcase */
+        };
+        // Substitute variables and get content
+        return this.templateLoader.substituteVariables(mcpBaseTemplate, context);
+    }
+}

package/dist/infra/context-tree/file-context-tree-writer-service.d.ts

@@ -15,11 +15,14 @@ export declare class FileContextTreeWriterService implements IContextTreeWriterS
     private readonly snapshotService;
     constructor(dependencies: ContextTreeWriterServiceDependencies, config?: ContextTreeWriterServiceConfig);
     sync(params: SyncParams): Promise<SyncResult>;
+    /**
+     * Builds a map of remote files with normalized paths.
+     * Filters out README.md at root level to match getCurrentState behavior.
+     */
+    private buildRemoteFilesMap;
     /**
      * Normalizes a file path by converting backslashes to forward slashes
      * and removing leading slashes.
-     * Ensures cross-platform compatibility and handles legacy API responses
-     * that may include leading slashes or Windows-style backslashes.
      */
     private normalizePath;
 }

package/dist/infra/context-tree/file-context-tree-writer-service.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-await-in-loop */
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+import { BRV_DIR, CONTEXT_TREE_DIR, README_FILE } from '../../constants.js';
 import { toUnixPath } from './path-utils.js';
 /**
  * File-based implementation of IContextTreeWriterService.
@@ -19,8 +19,9 @@ export class FileContextTreeWriterService {
         const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
         // Get current local state
         const localState = await this.snapshotService.getCurrentState(params.directory);
-        // Build map of remote files (normalize paths - remove leading /)
-        const remoteFiles = new Map(params.files.map((file) => [this.normalizePath(file.path), file]));
+        // Build map of remote files, filtering out README.md at root level
+        // This matches getCurrentState behavior which also excludes root README.md
+        const remoteFiles = this.buildRemoteFilesMap(params.files);
         const added = [];
         const edited = [];
         const deleted = [];
@@ -53,11 +54,25 @@ export class FileContextTreeWriterService {
         }
         return { added, deleted, edited };
     }
+    /**
+     * Builds a map of remote files with normalized paths.
+     * Filters out README.md at root level to match getCurrentState behavior.
+     */
+    buildRemoteFilesMap(files) {
+        const result = new Map();
+        for (const file of files) {
+            const normalizedPath = this.normalizePath(file.path);
+            // Skip README.md at root level (matches getCurrentState behavior)
+            if (normalizedPath === README_FILE) {
+                continue;
+            }
+            result.set(normalizedPath, file);
+        }
+        return result;
+    }
     /**
      * Normalizes a file path by converting backslashes to forward slashes
      * and removing leading slashes.
-     * Ensures cross-platform compatibility and handles legacy API responses
-     * that may include leading slashes or Windows-style backslashes.
      */
     normalizePath(path) {
         return toUnixPath(path).replace(/^\/+/, '');

package/dist/infra/core/executors/curate-executor.d.ts

@@ -23,8 +23,8 @@ export declare class CurateExecutor implements ICurateExecutor {
      *
      * @param filePaths - Array of file paths (relative or absolute)
      * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
-     * @returns Formatted instructions for the agent to read the specified files,
-     *          or undefined if validation fails
+     * @returns Formatted instructions for the agent to read the specified files
+     * @throws {FileValidationError} If any file validation fails
      */
     private processFileReferences;
 }

package/dist/infra/core/executors/curate-executor.js

@@ -19,10 +19,8 @@ export class CurateExecutor {
     static MAX_FILES = 5;
     async executeWithAgent(agent, options) {
         const { clientCwd, content, files, taskId } = options;
+        // Process file references (throws FileValidationError if validation fails)
         const fileReferenceInstructions = this.processFileReferences(files ?? [], clientCwd);
-        if (fileReferenceInstructions === undefined) {
-            throw new FileValidationError();
-        }
         // Build prompt with optional file reference instructions
         const prompt = fileReferenceInstructions ? `${content}\n${fileReferenceInstructions}` : content;
         // Execute with curate commandType
@@ -39,8 +37,8 @@ export class CurateExecutor {
      *
      * @param filePaths - Array of file paths (relative or absolute)
      * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
-     * @returns Formatted instructions for the agent to read the specified files,
-     *          or undefined if validation fails
+     * @returns Formatted instructions for the agent to read the specified files
+     * @throws {FileValidationError} If any file validation fails
      */
     processFileReferences(filePaths, clientCwd) {
         if (!filePaths || filePaths.length === 0) {
@@ -64,9 +62,10 @@ export class CurateExecutor {
                 errors.push(result.error ?? `Invalid file: ${filePath}`);
             }
         }
-        // If there are any validation errors, return undefined
+        // If there are any validation errors, throw with specific messages
         if (errors.length > 0) {
-            return undefined;
+            const errorMessage = `File validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`;
+            throw new FileValidationError(errorMessage);
         }
         // Format instructions for the agent
         const instructions = [
@@ -80,6 +79,7 @@ export class CurateExecutor {
             '- You MUST use the `read_file` tool to read ALL of these files IN PARALLEL (in a single iteration) before proceeding to create knowledge topics',
             '- These files contain essential context that will help you create comprehensive and accurate knowledge topics',
             '- Read them in parallel to maximize efficiency - they do not depend on each other',
+            '- **CRITICAL:** Only curate files where `read_file` returns `success: true`. Files that return `success: false` are error messages and should not be curated.',
             '- After reading all files, proceed with the normal workflow: detect domains, find existing knowledge, and create/update topics',
             '',
         ];

package/dist/infra/core/executors/query-executor.d.ts

@@ -11,7 +11,19 @@ import type { IQueryExecutor, QueryExecuteOptions } from '../../../core/interfac
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
  * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on query execution
+ *
+ * Enhanced with multi-perspective search strategy for comprehensive results.
  */
 export declare class QueryExecutor implements IQueryExecutor {
     executeWithAgent(agent: ICipherAgent, options: QueryExecuteOptions): Promise<string>;
+    /**
+     * Build an enhanced query prompt with multi-perspective search instructions.
+     *
+     * The prompt instructs the agent to:
+     * 1. Analyze the query to understand intent
+     * 2. Generate 2-3 search perspectives for comprehensive coverage
+     * 3. Execute searches using the task tool with explore subagents
+     * 4. Synthesize results into a cohesive answer with citations
+     */
+    private buildQueryPrompt;
 }

package/dist/infra/core/executors/query-executor.js

@@ -9,6 +9,8 @@
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
  * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on query execution
+ *
+ * Enhanced with multi-perspective search strategy for comprehensive results.
  */
 export class QueryExecutor {
     async executeWithAgent(agent, options) {
@@ -16,11 +18,70 @@ export class QueryExecutor {
         // Execute with query commandType
         // Agent uses its default session (created during start())
         // Task lifecycle is managed by Transport (task:started, task:completed, task:error)
-        const prompt = `Search the context tree for: ${query}`;
+        const prompt = this.buildQueryPrompt(query);
         const response = await agent.execute(prompt, {
             executionContext: { commandType: 'query' },
             taskId,
         });
         return response;
     }
+    /**
+     * Build an enhanced query prompt with multi-perspective search instructions.
+     *
+     * The prompt instructs the agent to:
+     * 1. Analyze the query to understand intent
+     * 2. Generate 2-3 search perspectives for comprehensive coverage
+     * 3. Execute searches using the task tool with explore subagents
+     * 4. Synthesize results into a cohesive answer with citations
+     */
+    buildQueryPrompt(query) {
+        return `## User Query
+${query}
+
+## Query Processing Instructions
+
+You are searching the context tree to answer the user's question. Follow this strategy for comprehensive results:
+
+### Step 1: Query Analysis
+First, analyze the query:
+- What is the user trying to learn? (core intent)
+- What are the key concepts mentioned?
+- Is this a factual, analytical, or exploratory question?
+
+### Step 2: Multi-Perspective Search
+Generate 2-3 complementary search perspectives:
+
+1. **Direct Search**: Use exact terms from the query
+2. **Related Concepts**: Search for synonyms, related terms, technical jargon
+3. **Implementation Patterns**: Search for how things are used or implemented
+
+### Step 3: Execute Parallel Searches
+Use the \`task\` tool to spawn explore subagents for each perspective:
+- Each subagent focuses on ONE search angle
+- Use \`contextTreeOnly=true\` to search only the context tree
+- Provide clear, specific search instructions
+
+Example:
+\`\`\`
+task(
+  subagentType="explore",
+  description="Search [perspective]",
+  prompt="Search for [specific terms]. Look in .brv/context-tree/ for [what to find].",
+  contextTreeOnly=true
+)
+\`\`\`
+
+### Step 4: Synthesize Results
+After gathering information:
+1. Identify overlapping findings (likely most relevant)
+2. Combine unique insights from each perspective
+3. Provide a clear, organized answer
+4. Cite sources with file paths
+
+### Response Format
+- **Summary**: Brief answer (2-3 sentences)
+- **Details**: Expanded explanation with findings
+- **Sources**: File paths for referenced information
+- **Gaps**: Note any aspects that couldn't be answered`;
+    }
 }

package/dist/infra/file/fs-file-service.d.ts

@@ -4,6 +4,13 @@ import { type IFileService, type WriteMode } from '../../core/interfaces/i-file-
  */
 export declare class FsFileService implements IFileService {
     createBackup(filePath: string): Promise<string>;
+    /**
+     * Deletes a file at the specified path.
+     *
+     * @param filePath The path to the file to delete.
+     * @returns A promise that resolves when the file has been deleted.
+     */
+    delete(filePath: string): Promise<void>;
     /**
      * Checks if a file exists at the specified path.
      *

package/dist/infra/file/fs-file-service.js

@@ -1,4 +1,4 @@
-import { access, appendFile, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, appendFile, copyFile, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 /**
  * File service implementation using Node.js fs module.
@@ -16,6 +16,20 @@ export class FsFileService {
             throw new Error(`Failed to create backup file '${filePath}': ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Deletes a file at the specified path.
+     *
+     * @param filePath The path to the file to delete.
+     * @returns A promise that resolves when the file has been deleted.
+     */
+    async delete(filePath) {
+        try {
+            await unlink(filePath);
+        }
+        catch (error) {
+            throw new Error(`Failed to delete file '${filePath}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
     /**
      * Checks if a file exists at the specified path.
      *

package/dist/infra/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export { ByteRoverMcpServer, type McpServerConfig } from './mcp-server.js';
+export { registerBrvCurateTool, registerBrvQueryTool, waitForTaskResult } from './tools/index.js';

package/dist/infra/mcp/index.js

@@ -0,0 +1,2 @@
+export { ByteRoverMcpServer } from './mcp-server.js';
+export { registerBrvCurateTool, registerBrvQueryTool, waitForTaskResult } from './tools/index.js';

package/dist/infra/mcp/mcp-server.d.ts

@@ -0,0 +1,58 @@
+export interface McpServerConfig {
+    /** CLI version for MCP server identification */
+    version: string;
+    /** Working directory for file operations */
+    workingDirectory: string;
+}
+/**
+ * ByteRover MCP Server.
+ *
+ * Exposes brv-query and brv-curate as MCP tools for coding agents.
+ * Connects to a running brv instance via Socket.IO transport.
+ *
+ * Architecture:
+ * - Coding agent spawns `brv mcp` process
+ * - MCP server connects to running brv instance via Socket.IO
+ * - MCP tools create tasks via transport
+ * - Tasks are executed by the existing agent process
+ */
+export declare class ByteRoverMcpServer {
+    private client;
+    private readonly config;
+    private currentReconnectDelay;
+    private isReconnecting;
+    private reconnectTimer;
+    private readonly server;
+    private transport;
+    constructor(config: McpServerConfig);
+    /**
+     * Starts the MCP server.
+     *
+     * 1. Connects to running brv instance via Socket.IO
+     * 2. Starts MCP server with stdio transport
+     *
+     * @throws NoInstanceRunningError - No brv instance is running
+     * @throws ConnectionFailedError - Failed to connect to brv instance
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the MCP server.
+     *
+     * Disconnects from the brv instance.
+     */
+    stop(): Promise<void>;
+    /**
+     * Attempts to reconnect to the brv instance.
+     * Uses exponential backoff for retry delays.
+     */
+    private attemptReconnect;
+    /**
+     * Log to stderr (stdout is reserved for MCP protocol).
+     */
+    private log;
+    /**
+     * Sets up the state change handler for a client.
+     * Handles disconnection by triggering auto-reconnect.
+     */
+    private setupStateChangeHandler;
+}

package/dist/infra/mcp/mcp-server.js

@@ -0,0 +1,178 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createTransportClientFactory } from '../transport/transport-client-factory.js';
+import { registerBrvCurateTool, registerBrvQueryTool } from './tools/index.js';
+/** Reconnection configuration */
+const RECONNECT_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
+const RECONNECT_BACKOFF_MULTIPLIER = 1.5;
+/**
+ * ByteRover MCP Server.
+ *
+ * Exposes brv-query and brv-curate as MCP tools for coding agents.
+ * Connects to a running brv instance via Socket.IO transport.
+ *
+ * Architecture:
+ * - Coding agent spawns `brv mcp` process
+ * - MCP server connects to running brv instance via Socket.IO
+ * - MCP tools create tasks via transport
+ * - Tasks are executed by the existing agent process
+ */
+export class ByteRoverMcpServer {
+    client;
+    config;
+    currentReconnectDelay = RECONNECT_DELAY_MS;
+    isReconnecting = false;
+    reconnectTimer;
+    server;
+    transport;
+    constructor(config) {
+        this.config = config;
+        this.server = new McpServer({
+            name: 'byterover',
+            version: config.version,
+        });
+        // Register tools with lazy client getter
+        // Client will be set when start() is called
+        registerBrvQueryTool(this.server, () => this.client, () => this.config.workingDirectory);
+        registerBrvCurateTool(this.server, () => this.client, () => this.config.workingDirectory);
+    }
+    /**
+     * Starts the MCP server.
+     *
+     * 1. Connects to running brv instance via Socket.IO
+     * 2. Starts MCP server with stdio transport
+     *
+     * @throws NoInstanceRunningError - No brv instance is running
+     * @throws ConnectionFailedError - Failed to connect to brv instance
+     */
+    async start() {
+        this.log('Starting MCP server...');
+        this.log(`Working directory: ${this.config.workingDirectory}`);
+        // Connect to running brv instance
+        const factory = createTransportClientFactory();
+        this.log('Connecting to brv instance...');
+        let connectionResult;
+        try {
+            connectionResult = await factory.connect(this.config.workingDirectory);
+        }
+        catch (error) {
+            this.log(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+        const { client, projectRoot } = connectionResult;
+        this.client = client;
+        this.log(`Connected to brv instance at ${projectRoot}`);
+        this.log(`Client ID: ${client.getClientId()}`);
+        this.log(`Initial connection state: ${client.getState()}`);
+        // Monitor connection state changes and handle reconnection
+        this.setupStateChangeHandler(client);
+        // Start MCP server with stdio transport
+        this.transport = new StdioServerTransport();
+        await this.server.connect(this.transport);
+        this.log('MCP server started and ready for tool calls');
+        // Log client state periodically to debug connection issues
+        setInterval(() => {
+            if (this.client) {
+                this.log(`[heartbeat] Client state: ${this.client.getState()}, ID: ${this.client.getClientId()}`);
+            }
+            else {
+                this.log('[heartbeat] Client is undefined!');
+            }
+        }, 10_000);
+    }
+    /**
+     * Stops the MCP server.
+     *
+     * Disconnects from the brv instance.
+     */
+    async stop() {
+        // Clear any pending reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        this.isReconnecting = false;
+        if (this.client) {
+            await this.client.disconnect();
+            this.client = undefined;
+        }
+    }
+    /**
+     * Attempts to reconnect to the brv instance.
+     * Uses exponential backoff for retry delays.
+     */
+    async attemptReconnect() {
+        if (this.isReconnecting) {
+            this.log('Reconnection already in progress, skipping...');
+            return;
+        }
+        this.isReconnecting = true;
+        this.log(`Attempting to reconnect in ${this.currentReconnectDelay}ms...`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                const factory = createTransportClientFactory();
+                const result = await factory.connect(this.config.workingDirectory);
+                // Disconnect old client if it exists
+                if (this.client) {
+                    try {
+                        await this.client.disconnect();
+                    }
+                    catch {
+                        // Ignore disconnect errors on old client
+                    }
+                }
+                this.client = result.client;
+                this.log(`Reconnected successfully! Client ID: ${result.client.getClientId()}`);
+                // Reset backoff delay on successful connection
+                this.currentReconnectDelay = RECONNECT_DELAY_MS;
+                this.isReconnecting = false;
+                // Set up state change handler for the new client
+                this.setupStateChangeHandler(result.client);
+            }
+            catch (error) {
+                this.log(`Reconnection failed: ${error instanceof Error ? error.message : String(error)}`);
+                // Increase delay with exponential backoff (capped at max)
+                this.currentReconnectDelay = Math.min(this.currentReconnectDelay * RECONNECT_BACKOFF_MULTIPLIER, RECONNECT_MAX_DELAY_MS);
+                this.isReconnecting = false;
+                // Schedule next reconnection attempt
+                this.attemptReconnect();
+            }
+        }, this.currentReconnectDelay);
+    }
+    /**
+     * Log to stderr (stdout is reserved for MCP protocol).
+     */
+    log(msg) {
+        process.stderr.write(`[brv-mcp] ${msg}\n`);
+    }
+    /**
+     * Sets up the state change handler for a client.
+     * Handles disconnection by triggering auto-reconnect.
+     */
+    setupStateChangeHandler(client) {
+        client.onStateChange((state) => {
+            const timestamp = new Date().toISOString();
+            this.log(`[${timestamp}] Connection state changed: ${state}`);
+            switch (state) {
+                case 'connected': {
+                    this.log(`[${timestamp}] Connected to brv instance.`);
+                    // Reset backoff delay on successful connection
+                    this.currentReconnectDelay = RECONNECT_DELAY_MS;
+                    this.isReconnecting = false;
+                    break;
+                }
+                case 'disconnected': {
+                    this.log(`[${timestamp}] Socket disconnected from brv instance. Initiating reconnection...`);
+                    // Trigger auto-reconnect
+                    this.attemptReconnect();
+                    break;
+                }
+                case 'reconnecting': {
+                    this.log(`[${timestamp}] Socket.IO attempting to reconnect...`);
+                    break;
+                }
+            }
+        });
+    }
+}