byterover-cli 0.4.1 → 1.0.0

package/dist/infra/process/transport-handlers.js

@@ -0,0 +1,348 @@
+/**
+ * Transport Handlers - Message routing in Transport Process.
+ *
+ * Architecture v0.5.0:
+ * - Routes messages between clients (TUI, external CLIs) and Agent
+ * - Agent is a special client that registers via 'agent:register'
+ * - Client UseCase generates taskId, Transport validates and routes
+ * - NO TaskProcessor, NO business logic (just routing)
+ *
+ * Event naming convention:
+ * - task:* events are Transport-generated (ack, created, started, completed, error)
+ * - llmservice:* events are forwarded from Agent with ORIGINAL names
+ *
+ * Message flows:
+ * 1. Client → Transport: task:create {taskId, type, content}
+ *    Transport → Agent: task:execute {taskId, type, content, clientId}
+ *    Transport → Client: task:ack {taskId}
+ *    Transport → broadcast-room: task:created {taskId, type, content, files?}
+ *
+ * 2. Agent → Transport: llmservice:response {taskId, content}
+ *    Transport → Client (direct): llmservice:response
+ *    Transport → broadcast-room: llmservice:response (for TUI monitoring)
+ *
+ * 3. Agent → Transport: task:completed {taskId}
+ *    Transport → Client (direct): task:completed
+ *    Transport → broadcast-room: task:completed (for TUI monitoring)
+ *
+ * Special events:
+ * - agent:register: Agent identifies itself
+ * - agent:connected / agent:disconnected: Broadcast to all clients
+ * - broadcast-room: TUI joins this room to monitor all events
+ */
+import { AgentDisconnectedError, AgentNotAvailableError, serializeTaskError, } from '../../core/domain/errors/task-error.js';
+import { LlmEventNames, TransportAgentEventNames, TransportLlmEventList, TransportTaskEventNames, } from '../../core/domain/transport/schemas.js';
+import { eventLog, transportLog } from '../../utils/process-logger.js';
+// All message types are imported from core/domain/transport/schemas.ts
+// - TaskExecute: Transport → Agent (command)
+// - TaskStartedEvent, TaskCompletedEvent, TaskErrorEvent: Agent → Transport (task lifecycle events)
+// - LlmThinkingEvent, LlmChunkEvent, LlmResponseEvent, etc: Agent → Transport (LLM events)
+// ============================================================================
+// Transport Handlers
+// ============================================================================
+/**
+ * TransportHandlers - Routes messages between clients and Agent.
+ *
+ * This class is the "brain" of the Transport Process.
+ * It knows which client is the Agent and routes messages accordingly.
+ */
+export class TransportHandlers {
+    /** The Agent's client ID (set when Agent registers) */
+    agentClientId;
+    /** Track active tasks */
+    tasks = new Map();
+    /** Transport server reference */
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * Cleanup handlers.
+     */
+    cleanup() {
+        this.tasks.clear();
+        this.agentClientId = undefined;
+    }
+    /**
+     * Setup all message handlers.
+     */
+    setup() {
+        this.setupConnectionHandlers();
+        this.setupAgentHandlers();
+        this.setupClientHandlers();
+        this.setupAgentControlHandlers();
+    }
+    /**
+     * Handle Agent registration.
+     * Agent connects as Socket.IO client and sends 'agent:register'.
+     */
+    handleAgentRegister(clientId) {
+        transportLog(`Agent registered: ${clientId}`);
+        this.agentClientId = clientId;
+        // Broadcast to all clients that Agent is online
+        this.transport.broadcast(TransportAgentEventNames.CONNECTED, {});
+    }
+    /**
+     * Handle task:cancel request from client.
+     * Returns success:false if task not found or Agent not available.
+     * Emits task:cancelled terminal event when cancelled locally (no Agent).
+     */
+    handleTaskCancel(data, _clientId) {
+        const { taskId } = data;
+        transportLog(`Task cancel requested: ${taskId}`);
+        // Check if task exists
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return { error: 'Task not found', success: false };
+        }
+        // If Agent connected, forward cancel request
+        if (this.agentClientId) {
+            this.transport.sendTo(this.agentClientId, TransportTaskEventNames.CANCEL, { taskId });
+            return { success: true };
+        }
+        // No Agent - cancel task locally and emit terminal event
+        transportLog(`No Agent connected, cancelling task locally: ${taskId}`);
+        this.transport.sendTo(task.clientId, TransportTaskEventNames.CANCELLED, { taskId });
+        this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.CANCELLED, { taskId });
+        this.tasks.delete(taskId);
+        return { success: true };
+    }
+    /**
+     * Handle task:cancelled from Agent.
+     * Terminal event: task was cancelled before completion.
+     * Route to task owner + broadcast-room, then cleanup.
+     */
+    handleTaskCancelled(data) {
+        const { taskId } = data;
+        const task = this.tasks.get(taskId);
+        transportLog(`Task cancelled: ${taskId}`);
+        if (task) {
+            this.transport.sendTo(task.clientId, TransportTaskEventNames.CANCELLED, { taskId });
+        }
+        this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.CANCELLED, { taskId });
+        this.tasks.delete(taskId);
+    }
+    /**
+     * Handle task:completed from Agent.
+     * Route directly to task owner + broadcast-room for monitoring.
+     */
+    handleTaskCompleted(data) {
+        const { result, taskId } = data;
+        const task = this.tasks.get(taskId);
+        transportLog(`Task completed: ${taskId}`);
+        if (task) {
+            this.transport.sendTo(task.clientId, TransportTaskEventNames.COMPLETED, { result, taskId });
+        }
+        this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.COMPLETED, { result, taskId });
+        this.tasks.delete(taskId);
+    }
+    /**
+     * Handle task:create request from client.
+     * Validate taskId from client, add to tracking, forward to Agent.
+     */
+    handleTaskCreate(data, clientId) {
+        const { taskId } = data;
+        // Duplicate check - reject if taskId already exists
+        if (this.tasks.has(taskId)) {
+            throw new Error(`Task ${taskId} already exists`);
+        }
+        transportLog(`Task accepted: ${taskId} (type=${data.type}, client=${clientId})`);
+        // Track task (clientId used for direct messaging)
+        this.tasks.set(taskId, {
+            clientId,
+            content: data.content,
+            createdAt: Date.now(),
+            ...(data.files?.length ? { files: data.files } : {}),
+            taskId,
+            type: data.type,
+        });
+        // Send ack immediately (fast feedback)
+        this.transport.sendTo(clientId, TransportTaskEventNames.ACK, { taskId });
+        // Broadcast task:created to broadcast-room for TUI monitoring
+        this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.CREATED, {
+            content: data.content,
+            ...(data.files?.length ? { files: data.files } : {}),
+            taskId,
+            type: data.type,
+        });
+        // Forward to Agent
+        if (this.agentClientId) {
+            const executeMsg = {
+                clientId,
+                content: data.content,
+                ...(data.files?.length ? { files: data.files } : {}),
+                taskId,
+                type: data.type,
+            };
+            this.transport.sendTo(this.agentClientId, TransportTaskEventNames.EXECUTE, executeMsg);
+        }
+        else {
+            // No Agent connected - send error immediately to client AND broadcast-room, then cleanup
+            transportLog(`No Agent connected, cannot process task ${taskId}`);
+            const error = serializeTaskError(new AgentNotAvailableError());
+            this.transport.sendTo(clientId, TransportTaskEventNames.ERROR, { error, taskId });
+            this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.ERROR, { error, taskId });
+            this.tasks.delete(taskId);
+        }
+        return { taskId };
+    }
+    /**
+     * Handle task:error from Agent.
+     * Route directly to task owner + broadcast-room for monitoring.
+     */
+    handleTaskError(data) {
+        const { error, taskId } = data;
+        const task = this.tasks.get(taskId);
+        transportLog(`Task error: ${taskId} - [${error.code}] ${error.message}`);
+        if (task) {
+            this.transport.sendTo(task.clientId, TransportTaskEventNames.ERROR, { error, taskId });
+        }
+        this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.ERROR, { error, taskId });
+        this.tasks.delete(taskId);
+    }
+    /**
+     * Handle task:started from Agent.
+     * Route directly to task owner + broadcast-room for monitoring.
+     */
+    handleTaskStarted(data) {
+        const { taskId } = data;
+        const task = this.tasks.get(taskId);
+        if (task) {
+            this.transport.sendTo(task.clientId, TransportTaskEventNames.STARTED, { taskId });
+            // Broadcast with task info for monitoring
+            // Note: fileReferenceInstructions is generated by UseCase during execution,
+            // so it's not available at task:started time. It's saved to DB instead.
+            this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.STARTED, {
+                content: task.content,
+                ...(task.files?.length ? { files: task.files } : {}),
+                taskId,
+                type: task.type,
+            });
+        }
+        else {
+            // Fallback if task not found
+            this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.STARTED, { taskId });
+        }
+    }
+    registerLlmEvent(eventName) {
+        this.transport.onRequest(eventName, (data) => {
+            this.routeLlmEvent(eventName, data);
+        });
+    }
+    /**
+     * Generic handler for routing LLM events from Agent to clients.
+     * Routes directly to task owner + broadcast-room for monitoring.
+     *
+     * All llmservice:* events follow the same routing pattern:
+     * 1. Extract taskId from payload
+     * 2. Check if task is still active (not completed/cancelled/errored)
+     * 3. Send to task owner + broadcast-room if active
+     * 4. Drop silently if task already ended (prevents events-after-terminal)
+     */
+    routeLlmEvent(eventName, data) {
+        const { taskId, ...rest } = data;
+        const task = this.tasks.get(taskId);
+        // Guard: Drop events for tasks that have already ended (terminal state reached)
+        // This prevents "ghost events" arriving after task:completed/cancelled/error
+        if (!task) {
+            return;
+        }
+        this.transport.sendTo(task.clientId, eventName, { taskId, ...rest });
+        this.transport.broadcastTo('broadcast-room', eventName, { taskId, ...rest });
+    }
+    /**
+     * Setup agent control handlers.
+     * These handle commands to control the Agent process (restart, etc.)
+     */
+    setupAgentControlHandlers() {
+        // agent:restart - Client requests Agent to reinitialize
+        this.transport.onRequest(TransportAgentEventNames.RESTART, (data, clientId) => {
+            transportLog(`Agent restart requested by ${clientId}: ${data.reason ?? 'no reason'}`);
+            if (!this.agentClientId) {
+                return { error: 'Agent not connected', success: false };
+            }
+            // Forward restart command to Agent
+            this.transport.sendTo(this.agentClientId, TransportAgentEventNames.RESTART, { reason: data.reason });
+            // Broadcast and log event
+            eventLog('agent:restarting', { reason: data.reason });
+            this.transport.broadcast(TransportAgentEventNames.RESTARTING, { reason: data.reason });
+            return { success: true };
+        });
+        // agent:restarted - Agent reports restart result
+        this.transport.onRequest(TransportAgentEventNames.RESTARTED, (data) => {
+            if (data.success) {
+                transportLog('Agent restarted successfully');
+                eventLog('agent:restarted', { success: true });
+                this.transport.broadcast(TransportAgentEventNames.RESTARTED, { success: true });
+            }
+            else {
+                transportLog(`Agent restart failed: ${data.error}`);
+                eventLog('agent:restarted', { error: data.error, success: false });
+                this.transport.broadcast(TransportAgentEventNames.RESTARTED, { error: data.error, success: false });
+            }
+        });
+    }
+    /**
+     * Setup Agent-related handlers.
+     * These handle events FROM the Agent.
+     */
+    setupAgentHandlers() {
+        // Agent registration
+        this.transport.onRequest(TransportAgentEventNames.REGISTER, (_data, clientId) => {
+            this.handleAgentRegister(clientId);
+            return { success: true };
+        });
+        // Task lifecycle events (Transport-generated names)
+        this.transport.onRequest(TransportTaskEventNames.STARTED, (data) => {
+            this.handleTaskStarted(data);
+        });
+        this.transport.onRequest(TransportTaskEventNames.COMPLETED, (data) => {
+            this.handleTaskCompleted(data);
+        });
+        this.transport.onRequest(TransportTaskEventNames.ERROR, (data) => {
+            this.handleTaskError(data);
+        });
+        this.transport.onRequest(TransportTaskEventNames.CANCELLED, (data) => {
+            this.handleTaskCancelled(data);
+        });
+        // LLM events - explicit list + typed payload map
+        for (const eventName of TransportLlmEventList) {
+            this.registerLlmEvent(eventName);
+        }
+    }
+    /**
+     * Setup client-related handlers.
+     * These handle events FROM clients (TUI, external CLIs).
+     */
+    setupClientHandlers() {
+        // Task creation from clients
+        this.transport.onRequest(TransportTaskEventNames.CREATE, (data, clientId) => this.handleTaskCreate(data, clientId));
+        // Task cancellation from clients
+        this.transport.onRequest(TransportTaskEventNames.CANCEL, (data, clientId) => this.handleTaskCancel(data, clientId));
+    }
+    /**
+     * Setup connection event handlers.
+     */
+    setupConnectionHandlers() {
+        this.transport.onConnection((clientId) => {
+            transportLog(`Client connected: ${clientId}`);
+        });
+        this.transport.onDisconnection((clientId) => {
+            transportLog(`Client disconnected: ${clientId}`);
+            // Check if Agent disconnected
+            if (clientId === this.agentClientId) {
+                transportLog('Agent disconnected!');
+                this.agentClientId = undefined;
+                // Broadcast to all clients
+                this.transport.broadcast(TransportAgentEventNames.DISCONNECTED, {});
+                // Fail all pending tasks - send to client AND broadcast-room for TUI monitoring
+                const error = serializeTaskError(new AgentDisconnectedError());
+                for (const [taskId, task] of this.tasks) {
+                    this.transport.sendTo(task.clientId, TransportTaskEventNames.ERROR, { error, taskId });
+                    this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.ERROR, { error, taskId });
+                }
+                this.tasks.clear();
+            }
+        });
+    }
+}

package/dist/infra/process/transport-worker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Transport Worker - Entry point for Transport Process.
+ *
+ * Architecture v0.5.0:
+ * - ONLY runs Socket.IO server (message hub)
+ * - Routes messages between clients (TUI, external CLIs) and Agent
+ * - NO TaskProcessor, NO CipherAgent, NO UseCases
+ * - Detects Agent connect/disconnect → broadcasts to clients
+ *
+ * IPC messages:
+ * - Receives: 'ping', 'shutdown'
+ * - Sends: 'ready' (with port), 'pong', 'stopped', 'error'
+ *
+ * Socket.IO events:
+ * - Client → Transport: task:create, task:cancel, session:*
+ * - Transport → Agent: task:create, task:cancel, shutdown
+ * - Agent → Transport: task:started, task:chunk, task:completed, task:error, task:toolCall, task:toolResult
+ * - Transport → Client: task:ack, task:started, task:chunk, task:completed, task:error, agent:connected, agent:disconnected
+ */
+export {};

package/dist/infra/process/transport-worker.js

@@ -0,0 +1,168 @@
+/**
+ * Transport Worker - Entry point for Transport Process.
+ *
+ * Architecture v0.5.0:
+ * - ONLY runs Socket.IO server (message hub)
+ * - Routes messages between clients (TUI, external CLIs) and Agent
+ * - NO TaskProcessor, NO CipherAgent, NO UseCases
+ * - Detects Agent connect/disconnect → broadcasts to clients
+ *
+ * IPC messages:
+ * - Receives: 'ping', 'shutdown'
+ * - Sends: 'ready' (with port), 'pong', 'stopped', 'error'
+ *
+ * Socket.IO events:
+ * - Client → Transport: task:create, task:cancel, session:*
+ * - Transport → Agent: task:create, task:cancel, shutdown
+ * - Agent → Transport: task:started, task:chunk, task:completed, task:error, task:toolCall, task:toolResult
+ * - Transport → Client: task:ack, task:started, task:chunk, task:completed, task:error, agent:connected, agent:disconnected
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { BRV_DIR, INSTANCE_FILE } from '../../constants.js';
+import { transportLog } from '../../utils/process-logger.js';
+import { FileInstanceManager } from '../instance/file-instance-manager.js';
+import { findAvailablePort } from '../transport/port-utils.js';
+import { createTransportServer } from '../transport/transport-factory.js';
+import { TransportHandlers } from './transport-handlers.js';
+// IPC types imported from ./ipc-types.ts
+function sendToParent(message) {
+    process.send?.(message);
+}
+// ============================================================================
+// Transport Process
+// ============================================================================
+let transportServer;
+let transportHandlers;
+let instancePollingInterval;
+const instanceManager = new FileInstanceManager();
+/** Polling interval in milliseconds */
+const INSTANCE_POLLING_INTERVAL_MS = 2000;
+/**
+ * Setup polling to detect instance.json deletion and recreate it.
+ *
+ * Why polling instead of fs.watch()?
+ * - fs.watch() on .brv/ directory silently stops when the directory is deleted
+ * - /init deletes entire .brv/ folder, causing watcher to become a dead listener
+ * - Polling is more reliable for this self-healing use case
+ */
+function setupInstancePolling(projectRoot, port) {
+    const instancePath = join(projectRoot, BRV_DIR, INSTANCE_FILE);
+    instancePollingInterval = setInterval(async () => {
+        // Check if instance.json exists
+        if (!existsSync(instancePath)) {
+            // Check if .brv directory exists (init might have recreated it)
+            const brvDir = join(projectRoot, BRV_DIR);
+            if (existsSync(brvDir)) {
+                // .brv exists but instance.json doesn't - recreate it
+                try {
+                    const result = await instanceManager.acquire(projectRoot, port);
+                    if (result.acquired) {
+                        transportLog('instance.json was deleted - recreated successfully');
+                    }
+                }
+                catch (error) {
+                    transportLog(`Could not recreate instance.json: ${error}`);
+                }
+            }
+            // If .brv doesn't exist, wait for /init to create it
+        }
+    }, INSTANCE_POLLING_INTERVAL_MS);
+    transportLog('Instance self-healing polling started');
+}
+/**
+ * Stop the instance polling.
+ */
+function stopInstancePolling() {
+    if (instancePollingInterval) {
+        clearInterval(instancePollingInterval);
+        instancePollingInterval = undefined;
+    }
+}
+async function startTransport() {
+    // Create Socket.IO server
+    transportServer = createTransportServer();
+    // Find available port
+    const port = await findAvailablePort();
+    // Start server
+    await transportServer.start(port);
+    // Write instance.json for discovery by clients (TUI, external CLIs)
+    const projectRoot = process.cwd();
+    const acquireResult = await instanceManager.acquire(projectRoot, port);
+    if (!acquireResult.acquired) {
+        throw new Error('brv is already running in this directory. ' +
+            'Please close the other instance first, or use a different terminal.');
+    }
+    // Setup message handlers (routing between clients and Agent)
+    transportHandlers = new TransportHandlers(transportServer);
+    transportHandlers.setup();
+    // Setup polling to recreate instance.json if deleted
+    setupInstancePolling(projectRoot, port);
+    transportLog(`Socket.IO server started on port ${port}`);
+    transportLog(`Instance registered at ${projectRoot}/.brv/instance.json`);
+    return port;
+}
+async function stopTransport() {
+    // Stop instance polling first
+    stopInstancePolling();
+    // Release instance.json
+    const projectRoot = process.cwd();
+    await instanceManager.release(projectRoot);
+    if (transportHandlers) {
+        transportHandlers.cleanup();
+        transportHandlers = undefined;
+    }
+    if (transportServer) {
+        await transportServer.stop();
+        transportServer = undefined;
+    }
+    transportLog('Socket.IO server stopped');
+}
+// ============================================================================
+// Worker Entry Point
+// ============================================================================
+async function runWorker() {
+    try {
+        const port = await startTransport();
+        sendToParent({ port, type: 'ready' });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        transportLog(`Failed to start: ${message}`);
+        sendToParent({ error: message, type: 'error' });
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        process.exit(1);
+    }
+    // IPC message handler
+    process.on('message', async (msg) => {
+        if (msg.type === 'ping') {
+            sendToParent({ type: 'pong' });
+        }
+        else if (msg.type === 'shutdown') {
+            await stopTransport();
+            sendToParent({ type: 'stopped' });
+            // eslint-disable-next-line n/no-process-exit
+            process.exit(0);
+        }
+    });
+    // Signal handlers
+    const cleanup = async () => {
+        await stopTransport();
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        process.exit(0);
+    };
+    process.once('SIGTERM', cleanup);
+    process.once('SIGINT', cleanup);
+    process.once('disconnect', cleanup);
+}
+// ============================================================================
+// Run
+// ============================================================================
+try {
+    await runWorker();
+}
+catch (error) {
+    transportLog(`Fatal error: ${error}`);
+    // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+    process.exit(1);
+}

package/dist/infra/repl/commands/curate-command.js

@@ -1,7 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isDevelopment } from '../../../config/environment.js';
 import { CommandKind } from '../../../tui/types.js';
-import { ProjectConfigStore } from '../../config/file-config-store.js';
 import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
 import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
 import { ReplTerminal } from '../../terminal/repl-terminal.js';
@@ -42,17 +41,13 @@ export const curateCommand = {
                 const tokenStore = new KeychainTokenStore();
                 const globalConfigStore = new FileGlobalConfigStore();
                 const useCase = new CurateUseCase({
-                    projectConfigStore: new ProjectConfigStore(),
                     terminal,
-                    tokenStore,
                     trackingService: new MixpanelTrackingService({ globalConfigStore, tokenStore }),
                 });
                 // Run the use case - mode determined by whether context is provided
                 await useCase.run({
-                    apiKey: flags.apiKey,
                     context: contextText,
                     files: files.length > 0 ? files : undefined,
-                    model: flags.model,
                     verbose: flags.verbose,
                 });
                 onMessage({

package/dist/infra/repl/commands/query-command.js

@@ -1,6 +1,5 @@
 import { isDevelopment } from '../../../config/environment.js';
 import { CommandKind } from '../../../tui/types.js';
-import { ProjectConfigStore } from '../../config/file-config-store.js';
 import { FileGlobalConfigStore } from "../../storage/file-global-config-store.js";
 import { KeychainTokenStore } from '../../storage/keychain-token-store.js';
 import { ReplTerminal } from '../../terminal/repl-terminal.js';
@@ -35,9 +34,7 @@ export const queryCommand = {
                 const tokenStore = new KeychainTokenStore();
                 const globalConfigStore = new FileGlobalConfigStore();
                 const useCase = new QueryUseCase({
-                    projectConfigStore: new ProjectConfigStore(),
                     terminal,
-                    tokenStore,
                     trackingService: new MixpanelTrackingService({ globalConfigStore, tokenStore }),
                 });
                 await useCase.run({

package/dist/infra/repl/repl-startup.d.ts

@@ -4,6 +4,10 @@ import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
 /**
  * Options for starting the REPL
+ *
+ * Architecture v0.5.0:
+ * - TUI discovers Transport via TransportClientFactory (same as external CLIs)
+ * - TUI is a Socket.IO client, Transport is the only server
  */
 export interface ReplOptions {
     onboardingPreferenceStore: IOnboardingPreferenceStore;

package/dist/infra/repl/repl-startup.js

@@ -3,11 +3,16 @@ import { render } from 'ink';
 import { App } from '../../tui/app.js';
 import { AppProviders } from '../../tui/providers/app-providers.js';
 import { stopQueuePollingService } from '../cipher/consumer/queue-polling-service.js';
+import { connectTransportClient, disconnectTransportClient } from './transport-client-helper.js';
+/** Broadcast client - joins broadcast-room to monitor all events */
+let transportBroadcastClient = null;
 /**
  * Start the ByteRover REPL
  */
 export async function startRepl(options) {
     const { onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version } = options;
+    // Connect broadcast client to monitor all events
+    transportBroadcastClient = await connectTransportClient();
     // Check initial auth state
     const authToken = await tokenStore.load();
     const isAuthorized = authToken !== undefined && authToken.isValid();
@@ -20,9 +25,11 @@ export async function startRepl(options) {
         }
     }
     await trackingService.track('repl', { status: 'started' });
-    // Render the App with providers
     const { waitUntilExit } = render(_jsx(AppProviders, { initialAuthToken: isAuthorized ? authToken : undefined, initialBrvConfig: brvConfig, onboardingPreferenceStore: onboardingPreferenceStore, projectConfigStore: projectConfigStore, tokenStore: tokenStore, trackingService: trackingService, version: version, children: _jsx(App, {}) }));
     await waitUntilExit();
+    // Cleanup
+    await disconnectTransportClient(transportBroadcastClient);
+    transportBroadcastClient = null;
     stopQueuePollingService();
     await trackingService.track('repl', { status: 'finished' });
 }

package/dist/infra/repl/transport-client-helper.d.ts

@@ -0,0 +1,9 @@
+import type { ITransportClient } from '../../core/interfaces/transport/i-transport-client.js';
+/**
+ * Connect to Transport and join TUI room for event monitoring.
+ */
+export declare function connectTransportClient(): Promise<ITransportClient | null>;
+/**
+ * Disconnect transport client.
+ */
+export declare function disconnectTransportClient(client: ITransportClient | null): Promise<void>;