byterover-cli 1.7.2 → 2.0.0

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

@@ -1,11 +1,10 @@
-import { connectToTransport } from '@campfirein/brv-transport-client';
+import { connectToDaemon, createDaemonReconnector, } from '@campfirein/brv-transport-client';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { TransportClientEventNames } from '../../core/domain/transport/schemas.js';
+import { resolveLocalServerMainPath } from '../../utils/server-main-resolver.js';
+import { detectMcpMode } from './mcp-mode-detector.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.
  *
@@ -19,23 +18,37 @@ const RECONNECT_BACKOFF_MULTIPLIER = 1.5;
  * - Tasks are executed by the existing agent process
  */
 export class ByteRoverMcpServer {
+    /** Cached agent name from MCP initialize handshake, re-sent on reconnect */
+    _agentName;
     client;
     config;
-    currentReconnectDelay = RECONNECT_DELAY_MS;
-    isReconnecting = false;
-    reconnectTimer;
+    connectOptions;
+    heartbeatInterval;
+    mode;
+    projectRoot;
+    reconnectorHandle;
     server;
     transport;
     constructor(config) {
         this.config = config;
+        const { mode, projectRoot } = detectMcpMode(config.workingDirectory);
+        this.mode = mode;
+        this.projectRoot = projectRoot;
         this.server = new McpServer({
             name: 'byterover',
             version: config.version,
         });
+        this.connectOptions = {
+            clientType: 'mcp',
+            fromDir: config.workingDirectory,
+            serverPath: resolveLocalServerMainPath(),
+            version: config.version,
+            ...(this.mode === 'project' && this.projectRoot ? { projectPath: this.projectRoot } : {}),
+        };
         // 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);
+        registerBrvQueryTool(this.server, () => this.client, () => this.getWorkingDirectory());
+        registerBrvCurateTool(this.server, () => this.client, () => this.getWorkingDirectory());
     }
     /**
      * Starts the MCP server.
@@ -49,31 +62,51 @@ export class ByteRoverMcpServer {
     async start() {
         this.log('Starting MCP server...');
         this.log(`Working directory: ${this.config.workingDirectory}`);
-        // Connect to running brv instance using modern API
+        this.log(`Mode: ${this.mode}`);
+        // Connect to running brv instance via connectToDaemon (single entry point)
+        // Project mode: registers with projectPath for project-scoped events
+        // Global mode: registers WITHOUT projectPath (serves multiple projects)
         this.log('Connecting to brv instance...');
-        let client;
-        let projectRoot;
-        try {
-            const result = await connectToTransport(this.config.workingDirectory);
-            client = result.client;
-            projectRoot = result.projectRoot;
-        }
-        catch (error) {
-            this.log(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
-        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);
+        const result = await connectToDaemon(this.connectOptions);
+        this.client = result.client;
+        this.log(`Connected to brv instance at ${result.projectRoot}`);
+        this.log(`Client ID: ${result.client.getClientId()}`);
+        this.log(`Initial connection state: ${result.client.getState()}`);
+        // Auto-reconnect on disconnect (shared logic from brv-transport-client)
+        this.reconnectorHandle = createDaemonReconnector(result.client, {
+            connectOptions: this.connectOptions,
+            onReconnected: (newClient) => {
+                this.client = newClient;
+                this.log(`Reconnected successfully! Client ID: ${newClient.getClientId()}`);
+                this.sendAgentName();
+            },
+            onStateChange: (state) => {
+                const timestamp = new Date().toISOString();
+                this.log(`[${timestamp}] Connection state changed: ${state}`);
+                // Socket.IO built-in reconnect: re-send agent name for new server-side clientId
+                if (state === 'connected') {
+                    this.sendAgentName();
+                }
+            },
+        });
+        // Capture the coding agent's identity after MCP initialize handshake
+        this.server.server.oninitialized = () => {
+            const clientVersion = this.server.server.getClientVersion();
+            if (clientVersion?.name && this.client) {
+                this._agentName = clientVersion.name;
+                this.log(`MCP client identified: ${clientVersion.name} v${clientVersion.version}`);
+                this.sendAgentName();
+            }
+            else {
+                this.log('MCP client did not provide clientInfo name');
+            }
+        };
         // 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(() => {
+        this.heartbeatInterval = setInterval(() => {
             if (this.client) {
                 this.log(`[heartbeat] Client state: ${this.client.getState()}, ID: ${this.client.getClientId()}`);
             }
@@ -88,58 +121,27 @@ export class ByteRoverMcpServer {
      * Disconnects from the brv instance.
      */
     async stop() {
-        // Clear any pending reconnection timer
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
+        // Cancel auto-reconnection
+        this.reconnectorHandle?.cancel();
+        this.reconnectorHandle = undefined;
+        // Clear heartbeat interval
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = 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.
+     * Returns the project root directory for MCP tool calls.
+     *
+     * In project mode, returns the discovered project root (where .brv/config.json lives).
+     * In global mode, returns undefined — each tool call must provide cwd.
      */
-    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 {
-                // Use modern connectToTransport API for reconnection
-                const result = await connectToTransport(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);
+    getWorkingDirectory() {
+        return this.mode === 'project' ? this.projectRoot : undefined;
     }
     /**
      * Log to stderr (stdout is reserved for MCP protocol).
@@ -148,32 +150,16 @@ export class ByteRoverMcpServer {
         process.stderr.write(`[brv-mcp] ${msg}\n`);
     }
     /**
-     * Sets up the state change handler for a client.
-     * Handles disconnection by triggering auto-reconnect.
+     * Sends the cached agent name to the daemon (fire-and-forget).
+     * Called after MCP initialize handshake and on Socket.IO reconnection.
      */
-    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;
-                }
-            }
+    sendAgentName() {
+        if (!this._agentName || !this.client)
+            return;
+        this.client
+            .requestWithAck(TransportClientEventNames.UPDATE_AGENT_NAME, { agentName: this._agentName })
+            .catch((error) => {
+            this.log(`Failed to send agent name: ${error instanceof Error ? error.message : String(error)}`);
         });
     }
 }

package/dist/server/infra/mcp/tools/brv-curate-tool.d.ts

@@ -1,24 +1,19 @@
 import type { ITransportClient } from '@campfirein/brv-transport-client';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-export declare const BrvCurateInputSchema: z.ZodEffects<z.ZodObject<{
+export declare const BrvCurateInputSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
     files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     folder: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     context?: string | undefined;
+    cwd?: string | undefined;
     files?: string[] | undefined;
     folder?: string | undefined;
 }, {
     context?: string | undefined;
-    files?: string[] | undefined;
-    folder?: string | undefined;
-}>, {
-    context?: string | undefined;
-    files?: string[] | undefined;
-    folder?: string | undefined;
-}, {
-    context?: string | undefined;
+    cwd?: string | undefined;
     files?: string[] | undefined;
     folder?: string | undefined;
 }>;
@@ -31,4 +26,4 @@ export declare const BrvCurateInputSchema: z.ZodEffects<z.ZodObject<{
  * Uses fire-and-forget pattern: returns immediately after queueing the task.
  * The curation is processed asynchronously by the ByteRover agent.
  */
-export declare function registerBrvCurateTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;
+export declare function registerBrvCurateTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string | undefined): void;

package/dist/server/infra/mcp/tools/brv-curate-tool.js

@@ -1,11 +1,20 @@
+import { waitForConnectedClient } from '@campfirein/brv-transport-client';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
-export const BrvCurateInputSchema = z
-    .object({
+import { TransportClientEventNames, TransportTaskEventNames } from '../../../core/domain/transport/schemas.js';
+import { detectMcpMode } from '../mcp-mode-detector.js';
+import { resolveClientCwd } from './resolve-client-cwd.js';
+export const BrvCurateInputSchema = z.object({
     context: z
         .string()
         .optional()
         .describe('Knowledge to store: patterns, decisions, errors, or insights about the codebase. Required unless files or folder are provided.'),
+    cwd: z
+        .string()
+        .optional()
+        .describe('Working directory of the project (absolute path). ' +
+        'Required when the MCP server runs in global mode (e.g., Windsurf). ' +
+        'Optional in project mode — defaults to the project directory.'),
     files: z
         .array(z.string())
         .max(5)
@@ -15,9 +24,6 @@ export const BrvCurateInputSchema = z
         .string()
         .optional()
         .describe('Folder path to pack and analyze (triggers folder pack flow). When provided, the entire folder will be analyzed and curated. Takes precedence over files.'),
-})
-    .refine((data) => Boolean(data.context?.trim()) || Boolean(data.files?.length) || Boolean(data.folder?.trim()), {
-    message: 'Either context, files, or folder must be provided',
 });
 /**
  * Registers the brv-curate tool with the MCP server.
@@ -30,30 +36,52 @@ export const BrvCurateInputSchema = z
  */
 export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
     server.registerTool('brv-curate', {
-        description: 'Store context to the ByteRover context tree. Save patterns, decisions, or insights.',
+        description: 'Store context to the ByteRover context tree. Save patterns, decisions, or insights. ' +
+            'Curation is processed asynchronously — the tool returns immediately after queueing.',
         inputSchema: BrvCurateInputSchema,
         title: 'ByteRover Curate',
-    }, async ({ context, files, folder }) => {
-        const client = getClient();
-        if (!client) {
+    }, async ({ context, cwd, files, folder }) => {
+        // Validate that at least one input is provided
+        if (!context?.trim() && !files?.length && !folder?.trim()) {
             return {
-                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                content: [{ text: 'Error: Either context, files, folder, or cwd must be provided', type: 'text' }],
                 isError: true,
             };
         }
-        // Check connection state before making request
-        const state = client.getState();
-        if (state !== 'connected') {
+        // Resolve clientCwd: explicit cwd param > server working directory
+        const cwdResult = resolveClientCwd(cwd, getWorkingDirectory);
+        if (!cwdResult.success) {
+            return {
+                content: [{ text: cwdResult.error, type: 'text' }],
+                isError: true,
+            };
+        }
+        // Wait for a connected client (MCP's attemptReconnect() replaces client in background)
+        const client = await waitForConnectedClient(getClient);
+        if (!client) {
             return {
                 content: [
                     {
-                        text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`,
+                        text: 'Error: Not connected to the daemon. Connection timed out. Ensure "brv" is running.',
                         type: 'text',
                     },
                 ],
                 isError: true,
             };
         }
+        // In global mode, associate client with the walked-up project root.
+        // Walk up from clientCwd to find .brv/config.json — raw cwd may be a subdirectory.
+        // Fire-and-forget: server handler is idempotent (first association wins).
+        if (!getWorkingDirectory()) {
+            const { projectRoot } = detectMcpMode(cwdResult.clientCwd);
+            if (projectRoot) {
+                client
+                    .requestWithAck(TransportClientEventNames.ASSOCIATE_PROJECT, {
+                    projectPath: projectRoot,
+                })
+                    .catch(() => { });
+            }
+        }
         try {
             const taskId = randomUUID();
             // Create task via transport (same pattern as brv curate command)
@@ -62,8 +90,8 @@ export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
             // Determine task type: folder pack takes precedence over file-based curate
             const hasFolder = Boolean(folder?.trim());
             const taskType = hasFolder ? 'curate-folder' : 'curate';
-            await client.requestWithAck('task:create', {
-                clientCwd: getWorkingDirectory(),
+            const ack = await client.requestWithAck(TransportTaskEventNames.CREATE, {
+                clientCwd: cwdResult.clientCwd,
                 content: resolvedContent,
                 taskId,
                 type: taskType,
@@ -72,11 +100,13 @@ export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
             });
             // Fire-and-forget: return immediately after task is queued
             // Curation is processed asynchronously by the ByteRover agent
+            const logId = ack?.logId;
             const modeDescription = hasFolder ? 'folder pack' : 'curation';
+            const logSuffix = logId ? `, logId: ${logId}` : '';
             return {
                 content: [
                     {
-                        text: `✓ Context queued for ${modeDescription} (taskId: ${taskId}). The curation will be processed asynchronously.`,
+                        text: `✓ Context queued for ${modeDescription} (taskId: ${taskId}${logSuffix}). The curation will be processed asynchronously.`,
                         type: 'text',
                     },
                 ],

package/dist/server/infra/mcp/tools/brv-query-tool.d.ts

@@ -2,11 +2,14 @@ import type { ITransportClient } from '@campfirein/brv-transport-client';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 export declare const BrvQueryInputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
     query: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     query: string;
+    cwd?: string | undefined;
 }, {
     query: string;
+    cwd?: string | undefined;
 }>;
 /**
  * Registers the brv-query tool with the MCP server.
@@ -14,4 +17,4 @@ export declare const BrvQueryInputSchema: z.ZodObject<{
  * This tool allows coding agents to query the ByteRover context tree
  * for patterns, decisions, implementation details, or any stored knowledge.
  */
-export declare function registerBrvQueryTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;
+export declare function registerBrvQueryTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string | undefined): void;

package/dist/server/infra/mcp/tools/brv-query-tool.js

@@ -1,7 +1,17 @@
+import { waitForConnectedClient } from '@campfirein/brv-transport-client';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+import { TransportClientEventNames, TransportTaskEventNames } from '../../../core/domain/transport/schemas.js';
+import { detectMcpMode } from '../mcp-mode-detector.js';
+import { resolveClientCwd } from './resolve-client-cwd.js';
 import { waitForTaskResult } from './task-result-waiter.js';
 export const BrvQueryInputSchema = z.object({
+    cwd: z
+        .string()
+        .optional()
+        .describe('Working directory of the project (absolute path). ' +
+        'Required when the MCP server runs in global mode (e.g., Windsurf). ' +
+        'Optional in project mode — defaults to the project directory.'),
     query: z.string().describe('Natural language question about the codebase or project'),
 });
 /**
@@ -15,38 +25,55 @@ export function registerBrvQueryTool(server, getClient, getWorkingDirectory) {
         description: 'Query the ByteRover context tree for patterns, decisions, or implementation details.',
         inputSchema: BrvQueryInputSchema,
         title: 'ByteRover Query',
-    }, async ({ query }) => {
-        const client = getClient();
-        if (!client) {
+    }, async ({ cwd, query }) => {
+        // Resolve clientCwd: explicit cwd param > server working directory
+        const cwdResult = resolveClientCwd(cwd, getWorkingDirectory);
+        if (!cwdResult.success) {
             return {
-                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                content: [{ text: cwdResult.error, type: 'text' }],
                 isError: true,
             };
         }
-        // Check connection state before making request
-        const state = client.getState();
-        if (state !== 'connected') {
+        // Wait for a connected client (MCP's attemptReconnect() replaces client in background)
+        const client = await waitForConnectedClient(getClient);
+        if (!client) {
             return {
                 content: [
                     {
-                        text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`,
+                        text: 'Error: Not connected to the daemon. Connection timed out. Ensure "brv" is running.',
                         type: 'text',
                     },
                 ],
                 isError: true,
             };
         }
+        // In global mode, associate client with the walked-up project root.
+        // Walk up from clientCwd to find .brv/config.json — raw cwd may be a subdirectory.
+        // Fire-and-forget: server handler is idempotent (first association wins).
+        if (!getWorkingDirectory()) {
+            const { projectRoot } = detectMcpMode(cwdResult.clientCwd);
+            if (projectRoot) {
+                client
+                    .requestWithAck(TransportClientEventNames.ASSOCIATE_PROJECT, {
+                    projectPath: projectRoot,
+                })
+                    .catch(() => { });
+            }
+        }
         try {
             const taskId = randomUUID();
+            // Register event listeners BEFORE sending task:create to avoid race conditions.
+            // If the task completes before listeners are set up, the task:completed event is missed.
+            const resultPromise = waitForTaskResult(client, taskId);
             // Create task via transport (same pattern as brv query command)
-            await client.requestWithAck('task:create', {
-                clientCwd: getWorkingDirectory(),
+            await client.requestWithAck(TransportTaskEventNames.CREATE, {
+                clientCwd: cwdResult.clientCwd,
                 content: query,
                 taskId,
                 type: 'query',
             });
-            // Wait for task completion and return result
-            const result = await waitForTaskResult(client, taskId);
+            // Wait for the already-listening result promise
+            const result = await resultPromise;
             return {
                 content: [{ text: result, type: 'text' }],
             };

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

@@ -1,3 +1,4 @@
 export { registerBrvCurateTool } from './brv-curate-tool.js';
 export { registerBrvQueryTool } from './brv-query-tool.js';
+export { resolveClientCwd } from './resolve-client-cwd.js';
 export { waitForTaskResult } from './task-result-waiter.js';

package/dist/server/infra/mcp/tools/index.js

@@ -1,3 +1,4 @@
 export { registerBrvCurateTool } from './brv-curate-tool.js';
 export { registerBrvQueryTool } from './brv-query-tool.js';
+export { resolveClientCwd } from './resolve-client-cwd.js';
 export { waitForTaskResult } from './task-result-waiter.js';

package/dist/server/infra/mcp/tools/resolve-client-cwd.d.ts

@@ -0,0 +1,17 @@
+export type CwdResolutionResult = {
+    clientCwd: string;
+    success: true;
+} | {
+    error: string;
+    success: false;
+};
+/**
+ * Resolves the effective clientCwd for an MCP tool call.
+ *
+ * Priority: explicit `cwd` parameter > server's working directory.
+ *
+ * In project mode, getWorkingDirectory() returns the project directory,
+ * so `cwd` is optional. In global mode, getWorkingDirectory() returns
+ * undefined, so `cwd` is required.
+ */
+export declare function resolveClientCwd(cwd: string | undefined, getWorkingDirectory: () => string | undefined): CwdResolutionResult;

package/dist/server/infra/mcp/tools/resolve-client-cwd.js

@@ -0,0 +1,27 @@
+import { isAbsolute } from 'node:path';
+/**
+ * Resolves the effective clientCwd for an MCP tool call.
+ *
+ * Priority: explicit `cwd` parameter > server's working directory.
+ *
+ * In project mode, getWorkingDirectory() returns the project directory,
+ * so `cwd` is optional. In global mode, getWorkingDirectory() returns
+ * undefined, so `cwd` is required.
+ */
+export function resolveClientCwd(cwd, getWorkingDirectory) {
+    const clientCwd = cwd ?? getWorkingDirectory();
+    if (!clientCwd) {
+        return {
+            error: 'Error: cwd parameter is required. The MCP server is running in global mode (not inside a ByteRover project). ' +
+                'Provide the project directory path in the cwd parameter.',
+            success: false,
+        };
+    }
+    if (!isAbsolute(clientCwd)) {
+        return {
+            error: 'Error: cwd must be an absolute path.',
+            success: false,
+        };
+    }
+    return { clientCwd, success: true };
+}

package/dist/server/infra/mcp/tools/task-result-waiter.js

@@ -1,3 +1,4 @@
+import { LlmEventNames, TransportTaskEventNames } from '../../../core/domain/transport/schemas.js';
 /**
  * Waits for a task to complete and returns the result.
  *
@@ -34,17 +35,17 @@ export async function waitForTaskResult(client, taskId, timeoutMs = 300_000) {
             if (state === 'disconnected' && !completed) {
                 completed = true;
                 cleanup();
-                reject(new Error('Connection lost to ByteRover instance'));
+                reject(new Error('Connection lost to the daemon'));
             }
         }), 
         // Listen for LLM response content
-        client.on('llmservice:response', (payload) => {
+        client.on(LlmEventNames.RESPONSE, (payload) => {
             if (payload.taskId === taskId && payload.content) {
                 result = payload.content;
             }
         }), 
         // Listen for task completion
-        client.on('task:completed', (payload) => {
+        client.on(TransportTaskEventNames.COMPLETED, (payload) => {
             if (payload.taskId === taskId && !completed) {
                 completed = true;
                 cleanup();
@@ -53,7 +54,7 @@ export async function waitForTaskResult(client, taskId, timeoutMs = 300_000) {
             }
         }), 
         // Listen for task error
-        client.on('task:error', (payload) => {
+        client.on(TransportTaskEventNames.ERROR, (payload) => {
             if (payload.taskId === taskId && !completed) {
                 completed = true;
                 cleanup();
@@ -61,7 +62,7 @@ export async function waitForTaskResult(client, taskId, timeoutMs = 300_000) {
             }
         }), 
         // Listen for task cancellation
-        client.on('task:cancelled', (payload) => {
+        client.on(TransportTaskEventNames.CANCELLED, (payload) => {
             if (payload.taskId === taskId && !completed) {
                 completed = true;
                 cleanup();

package/dist/server/infra/process/broadcast-utils.d.ts

@@ -0,0 +1,16 @@
+import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
+import type { IProjectRouter } from '../../core/interfaces/routing/i-project-router.js';
+/**
+ * Broadcast an event to the project-scoped room for a given projectPath.
+ * Silently skips if projectPath is unavailable, project not registered,
+ * or routing infrastructure is not configured.
+ *
+ * @param projectRegistry - Project registry for path lookup
+ * @param projectRouter - Router for room-scoped broadcasting
+ * @param projectPath - The project path to broadcast to
+ * @param event - The event name
+ * @param data - The event payload
+ * @param except - Optional client ID to exclude from the broadcast (prevents
+ *                 duplicates when the client already receives via sendTo)
+ */
+export declare function broadcastToProjectRoom<T = unknown>(projectRegistry: IProjectRegistry | undefined, projectRouter: IProjectRouter | undefined, projectPath: string | undefined, event: string, data: T, except?: string): void;

package/dist/server/infra/process/broadcast-utils.js

@@ -0,0 +1,22 @@
+/**
+ * Broadcast an event to the project-scoped room for a given projectPath.
+ * Silently skips if projectPath is unavailable, project not registered,
+ * or routing infrastructure is not configured.
+ *
+ * @param projectRegistry - Project registry for path lookup
+ * @param projectRouter - Router for room-scoped broadcasting
+ * @param projectPath - The project path to broadcast to
+ * @param event - The event name
+ * @param data - The event payload
+ * @param except - Optional client ID to exclude from the broadcast (prevents
+ *                 duplicates when the client already receives via sendTo)
+ */
+// eslint-disable-next-line max-params
+export function broadcastToProjectRoom(projectRegistry, projectRouter, projectPath, event, data, except) {
+    if (!projectPath || !projectRouter || !projectRegistry)
+        return;
+    const projectInfo = projectRegistry.get(projectPath);
+    if (projectInfo) {
+        projectRouter.broadcastToProject(projectInfo.sanitizedPath, event, data, except);
+    }
+}