byterover-cli 1.2.0 → 1.3.0

package/dist/infra/process/task-queue-manager.d.ts

@@ -1,21 +1,17 @@
 /**
- * TaskQueueManager - Manages in-memory task queues with concurrency control.
+ * TaskQueueManager - Manages in-memory task queue with FIFO sequential execution.
  *
  * Features:
- * - Separate queues for different task types (curate, query)
- * - Configurable concurrency limits per queue
+ * - Unified queue for all task types (curate, query)
+ * - Configurable concurrency limit (default: 1 for sequential execution)
  * - Task deduplication (same taskId can't be queued twice)
  * - Cancel tasks from queue before processing
- * - FIFO processing order
+ * - Strict FIFO processing order across all task types
  *
  * This class is extracted from agent-worker.ts to enable unit testing.
  */
-import type { TaskExecute } from '../../core/domain/transport/schemas.js';
-export type TaskType = 'curate' | 'query';
-export interface QueueConfig {
-    /** Maximum concurrent tasks for this queue */
-    maxConcurrent: number;
-}
+import type { TaskExecute, TaskType } from '../../core/domain/transport/schemas.js';
+export type { TaskType } from '../../core/domain/transport/schemas.js';
 export interface TaskQueueStats {
     /** Number of tasks currently being processed */
     active: number;
@@ -25,10 +21,10 @@ export interface TaskQueueStats {
     queued: number;
 }
 export interface TaskQueueManagerConfig {
-    curate: QueueConfig;
+    /** Maximum concurrent tasks (default: 1 for sequential execution) */
+    maxConcurrent?: number;
     /** Optional callback for executor errors (for logging/debugging) */
     onExecutorError?: (taskId: string, error: unknown) => void;
-    query: QueueConfig;
 }
 /**
  * Result of attempting to enqueue a task.
@@ -56,16 +52,14 @@ export type CancelResult = {
  */
 export type TaskExecutor = (task: TaskExecute) => Promise<void>;
 export declare class TaskQueueManager {
-    private activeCurateTasks;
-    private activeQueryTasks;
-    private readonly config;
-    private readonly curateQueue;
+    private activeTasks;
     /** Maps taskId → taskType for tracking (replaces Set for type awareness) */
     private readonly knownTasks;
+    private readonly maxConcurrent;
     private readonly onExecutorError?;
-    private readonly queryQueue;
+    private readonly queue;
     private taskExecutor;
-    constructor(config?: Partial<TaskQueueManagerConfig>);
+    constructor(config?: TaskQueueManagerConfig);
     /**
      * Cancel a task by taskId.
      * Removes from queue if waiting, or marks for cancellation if processing.
@@ -82,21 +76,22 @@ export declare class TaskQueueManager {
      */
     enqueue(task: TaskExecute): EnqueueResult;
     /**
-     * Get total active task count across all queues.
+     * Get total active task count.
      */
     getActiveCount(): number;
     /**
-     * Get all queue statistics.
+     * Get total queued task count.
      */
-    getAllStats(): Record<TaskType, TaskQueueStats>;
+    getQueuedCount(): number;
     /**
-     * Get total queued task count across all queues.
+     * Get a copy of all queued tasks (not including active tasks).
+     * Useful for notifying clients before clearing the queue.
      */
-    getQueuedCount(): number;
+    getQueuedTasks(): readonly TaskExecute[];
     /**
-     * Get statistics for a specific queue.
+     * Get statistics for the queue.
      */
-    getStats(type: TaskType): TaskQueueStats;
+    getStats(): TaskQueueStats;
     /**
      * Check if there are any active tasks (currently being processed).
      * Used to prevent reinit during task execution.
@@ -111,7 +106,7 @@ export declare class TaskQueueManager {
      * Should be called by executor when task finishes.
      * Guards against underflow from duplicate/invalid calls.
      */
-    markCompleted(taskId: string, type: TaskType): void;
+    markCompleted(taskId: string): void;
     /**
      * Set the task executor callback.
      * Called when a task is ready to be processed.
@@ -119,18 +114,12 @@ export declare class TaskQueueManager {
      */
     setExecutor(executor: TaskExecutor): void;
     /**
-     * Process all possible tasks from a queue (up to maxConcurrent).
-     * Handles Infinity maxConcurrent safely by using queue length as bound.
+     * Process all possible tasks from the queue (up to maxConcurrent).
      */
     private drainQueue;
     private executeTask;
     /**
-     * Get queue state for a task type (DRY helper).
-     */
-    private getQueueState;
-    /**
-     * Try to process the next task from a specific queue.
-     * Unified method replacing tryProcessNextCurate/tryProcessNextQuery.
+     * Try to process the next task from the queue.
      */
     private tryProcessNext;
 }

package/dist/infra/process/task-queue-manager.js

@@ -1,32 +1,26 @@
 /**
- * TaskQueueManager - Manages in-memory task queues with concurrency control.
+ * TaskQueueManager - Manages in-memory task queue with FIFO sequential execution.
  *
  * Features:
- * - Separate queues for different task types (curate, query)
- * - Configurable concurrency limits per queue
+ * - Unified queue for all task types (curate, query)
+ * - Configurable concurrency limit (default: 1 for sequential execution)
  * - Task deduplication (same taskId can't be queued twice)
  * - Cancel tasks from queue before processing
- * - FIFO processing order
+ * - Strict FIFO processing order across all task types
  *
  * This class is extracted from agent-worker.ts to enable unit testing.
  */
-import { CURATE_MAX_CONCURRENT } from './constants.js';
+import { isValidTaskType } from '../../utils/type-guards.js';
 export class TaskQueueManager {
-    activeCurateTasks = 0;
-    activeQueryTasks = 0;
-    config;
-    curateQueue = [];
+    activeTasks = 0;
     /** Maps taskId → taskType for tracking (replaces Set for type awareness) */
     knownTasks = new Map();
+    maxConcurrent;
     onExecutorError;
-    queryQueue = [];
+    queue = [];
     taskExecutor;
     constructor(config) {
-        this.config = {
-            curate: { maxConcurrent: config?.curate?.maxConcurrent ?? CURATE_MAX_CONCURRENT },
-            // Query tasks are unlimited (Infinity) - lightweight and fast
-            query: { maxConcurrent: config?.query?.maxConcurrent ?? Infinity },
-        };
+        this.maxConcurrent = config?.maxConcurrent ?? 1;
         this.onExecutorError = config?.onExecutorError;
     }
     /**
@@ -34,21 +28,15 @@ export class TaskQueueManager {
      * Removes from queue if waiting, or marks for cancellation if processing.
      */
     cancel(taskId) {
-        // Try to remove from curate queue
-        const curateIndex = this.curateQueue.findIndex((t) => t.taskId === taskId);
-        if (curateIndex !== -1) {
-            this.curateQueue.splice(curateIndex, 1);
-            this.knownTasks.delete(taskId);
-            return { success: true, taskType: 'curate', wasQueued: true };
-        }
-        // Try to remove from query queue
-        const queryIndex = this.queryQueue.findIndex((t) => t.taskId === taskId);
-        if (queryIndex !== -1) {
-            this.queryQueue.splice(queryIndex, 1);
+        // Try to remove from queue
+        const index = this.queue.findIndex((t) => t.taskId === taskId);
+        if (index !== -1) {
+            const task = this.queue[index];
+            this.queue.splice(index, 1);
             this.knownTasks.delete(taskId);
-            return { success: true, taskType: 'query', wasQueued: true };
+            return { success: true, taskType: task.type, wasQueued: true };
         }
-        // Check if task is currently processing - now we know the real taskType!
+        // Check if task is currently processing - get type from knownTasks
         const taskType = this.knownTasks.get(taskId);
         if (taskType) {
             // Task is processing - caller should handle cancellation via taskProcessor
@@ -61,10 +49,8 @@ export class TaskQueueManager {
      * Useful for testing or shutdown.
      */
     clear() {
-        this.curateQueue.length = 0;
-        this.queryQueue.length = 0;
-        this.activeCurateTasks = 0;
-        this.activeQueryTasks = 0;
+        this.queue.length = 0;
+        this.activeTasks = 0;
         this.knownTasks.clear();
     }
     /**
@@ -76,57 +62,43 @@ export class TaskQueueManager {
         if (this.knownTasks.has(task.taskId)) {
             return { reason: 'duplicate', success: false };
         }
-        // Validate task type
-        if (task.type !== 'curate' && task.type !== 'query') {
+        // Validate task type using type guard for compile-time safety
+        if (!isValidTaskType(task.type)) {
             return { reason: 'unknown_type', success: false };
         }
         // Register with type and enqueue
         this.knownTasks.set(task.taskId, task.type);
-        if (task.type === 'curate') {
-            this.curateQueue.push(task);
-            this.tryProcessNext('curate');
-            return { position: this.curateQueue.length, success: true };
-        }
-        this.queryQueue.push(task);
-        this.tryProcessNext('query');
-        return { position: this.queryQueue.length, success: true };
+        this.queue.push(task);
+        this.tryProcessNext();
+        return { position: this.queue.length, success: true };
     }
     /**
-     * Get total active task count across all queues.
+     * Get total active task count.
      */
     getActiveCount() {
-        return this.activeCurateTasks + this.activeQueryTasks;
+        return this.activeTasks;
     }
     /**
-     * Get all queue statistics.
+     * Get total queued task count.
      */
-    getAllStats() {
-        return {
-            curate: this.getStats('curate'),
-            query: this.getStats('query'),
-        };
+    getQueuedCount() {
+        return this.queue.length;
     }
     /**
-     * Get total queued task count across all queues.
+     * Get a copy of all queued tasks (not including active tasks).
+     * Useful for notifying clients before clearing the queue.
      */
-    getQueuedCount() {
-        return this.curateQueue.length + this.queryQueue.length;
+    getQueuedTasks() {
+        return [...this.queue];
     }
     /**
-     * Get statistics for a specific queue.
+     * Get statistics for the queue.
      */
-    getStats(type) {
-        if (type === 'curate') {
-            return {
-                active: this.activeCurateTasks,
-                maxConcurrent: this.config.curate.maxConcurrent,
-                queued: this.curateQueue.length,
-            };
-        }
+    getStats() {
         return {
-            active: this.activeQueryTasks,
-            maxConcurrent: this.config.query.maxConcurrent,
-            queued: this.queryQueue.length,
+            active: this.activeTasks,
+            maxConcurrent: this.maxConcurrent,
+            queued: this.queue.length,
         };
     }
     /**
@@ -134,7 +106,7 @@ export class TaskQueueManager {
      * Used to prevent reinit during task execution.
      */
     hasActiveTasks() {
-        return this.activeCurateTasks > 0 || this.activeQueryTasks > 0;
+        return this.activeTasks > 0;
     }
     /**
      * Check if a taskId is known (queued or processing).
@@ -147,24 +119,16 @@ export class TaskQueueManager {
      * Should be called by executor when task finishes.
      * Guards against underflow from duplicate/invalid calls.
      */
-    markCompleted(taskId, type) {
+    markCompleted(taskId) {
         // Guard: only decrement if task was actually known (prevents underflow)
         if (!this.knownTasks.has(taskId)) {
             return;
         }
         this.knownTasks.delete(taskId);
-        if (type === 'curate') {
-            if (this.activeCurateTasks > 0) {
-                this.activeCurateTasks--;
-            }
-            this.tryProcessNext('curate');
-        }
-        else {
-            if (this.activeQueryTasks > 0) {
-                this.activeQueryTasks--;
-            }
-            this.tryProcessNext('query');
+        if (this.activeTasks > 0) {
+            this.activeTasks--;
         }
+        this.tryProcessNext();
     }
     /**
      * Set the task executor callback.
@@ -174,26 +138,22 @@ export class TaskQueueManager {
     setExecutor(executor) {
         this.taskExecutor = executor;
         // Process any tasks that were queued before executor was set
-        // Use queue length as upper bound to handle Infinity maxConcurrent safely
-        this.drainQueue('curate');
-        this.drainQueue('query');
+        this.drainQueue();
     }
     /**
-     * Process all possible tasks from a queue (up to maxConcurrent).
-     * Handles Infinity maxConcurrent safely by using queue length as bound.
+     * Process all possible tasks from the queue (up to maxConcurrent).
      */
-    drainQueue(type) {
-        const state = this.getQueueState(type);
-        // Process up to queue length (safe for Infinity maxConcurrent)
-        const toProcess = Math.min(state.queue.length, state.config.maxConcurrent);
+    drainQueue() {
+        // Process up to maxConcurrent tasks
+        const toProcess = Math.min(this.queue.length, this.maxConcurrent);
         for (let i = 0; i < toProcess; i++) {
-            this.tryProcessNext(type);
+            this.tryProcessNext();
         }
     }
     // ============================================================================
     // Private Methods
     // ============================================================================
-    executeTask(task, type) {
+    executeTask(task) {
         this.taskExecutor(task)
             .catch((error) => {
             // Notify caller of executor error (for logging/debugging)
@@ -201,46 +161,25 @@ export class TaskQueueManager {
             this.onExecutorError?.(task.taskId, error);
         })
             .finally(() => {
-            this.markCompleted(task.taskId, type);
+            this.markCompleted(task.taskId);
         });
     }
     /**
-     * Get queue state for a task type (DRY helper).
-     */
-    getQueueState(type) {
-        if (type === 'curate') {
-            return {
-                active: this.activeCurateTasks,
-                config: this.config.curate,
-                incrementActive: () => this.activeCurateTasks++,
-                queue: this.curateQueue,
-            };
-        }
-        return {
-            active: this.activeQueryTasks,
-            config: this.config.query,
-            incrementActive: () => this.activeQueryTasks++,
-            queue: this.queryQueue,
-        };
-    }
-    /**
-     * Try to process the next task from a specific queue.
-     * Unified method replacing tryProcessNextCurate/tryProcessNextQuery.
+     * Try to process the next task from the queue.
      */
-    tryProcessNext(type) {
+    tryProcessNext() {
         // Don't process without executor - tasks stay in queue
         if (!this.taskExecutor) {
             return;
         }
-        const state = this.getQueueState(type);
-        if (state.active >= state.config.maxConcurrent) {
+        if (this.activeTasks >= this.maxConcurrent) {
             return;
         }
-        if (state.queue.length === 0) {
+        if (this.queue.length === 0) {
             return;
         }
-        const task = state.queue.shift();
-        state.incrementActive();
-        this.executeTask(task, type);
+        const task = this.queue.shift();
+        this.activeTasks++;
+        this.executeTask(task);
     }
 }

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

@@ -33,13 +33,7 @@
 import { AgentDisconnectedError, AgentNotAvailableError, AgentNotInitializedError, serializeTaskError, } from '../../core/domain/errors/task-error.js';
 import { AgentStatusEventNames, LlmEventNames, TransportAgentEventNames, TransportLlmEventList, TransportTaskEventNames, } from '../../core/domain/transport/schemas.js';
 import { eventLog, transportLog } from '../../utils/process-logger.js';
-/**
- * Type guard for valid task types.
- * Replaces unsafe `as` assertion per CLAUDE.md standards.
- */
-function isValidTaskType(type) {
-    return type === 'curate' || type === 'query';
-}
+import { isValidTaskType } from '../../utils/type-guards.js';
 // All message types are imported from core/domain/transport/schemas.ts
 // - TaskExecute: Transport → Agent (command)
 // - TaskStartedEvent, TaskCompletedEvent, TaskErrorEvent: Agent → Transport (task lifecycle events)

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

@@ -43,7 +43,7 @@ export const connectorsCommand = {
     }),
     aliases: [],
     autoExecute: true,
-    description: 'Manage agent connectors (rules, hooks)',
+    description: 'Manage agent connectors (rules, hook, mcp, or skill)',
     kind: CommandKind.BUILT_IN,
     name: 'connectors',
 };

package/dist/infra/transport/socket-io-transport-client.d.ts

@@ -72,6 +72,15 @@ export declare class SocketIOTransportClient implements ITransportClient {
      * Used when initiating new connection attempt - counter preserved for backoff continuity.
      */
     private clearForceReconnectTimer;
+    /**
+     * Remove all registered event listeners from socket.
+     * Used before re-registering to prevent listener accumulation across reconnects.
+     *
+     * Why this is needed: Socket.IO preserves the Socket instance across internal reconnects.
+     * If we clear registeredSocketEvents without calling socket.off(), the old listeners
+     * remain attached, and registerPendingEventHandlers() adds new ones - causing duplicates.
+     */
+    private clearSocketEventListeners;
     /**
      * Handle system wake from sleep/hibernate.
      * Re-triggers reconnection if not connected and force reconnect has given up.

package/dist/infra/transport/socket-io-transport-client.js

@@ -145,8 +145,10 @@ export class SocketIOTransportClient {
                 clientLog(`Socket.IO built-in reconnect succeeded after ${attemptNumber} attempts`);
                 this.setState('connected');
                 // Re-register event handlers after reconnect
-                // Clear tracking first since socket listeners were reset during reconnect
-                this.registeredSocketEvents.clear();
+                // FIX: Remove existing socket listeners before re-registering to prevent
+                // listener accumulation. Socket.IO preserves the Socket instance across
+                // internal reconnects, so old listeners remain attached if not removed.
+                this.clearSocketEventListeners();
                 this.registerPendingEventHandlers();
                 // Auto-rejoin rooms after reconnect
                 // Use process.nextTick to ensure socket.connected is true
@@ -408,6 +410,23 @@ export class SocketIOTransportClient {
             this.forceReconnectTimer = undefined;
         }
     }
+    /**
+     * Remove all registered event listeners from socket.
+     * Used before re-registering to prevent listener accumulation across reconnects.
+     *
+     * Why this is needed: Socket.IO preserves the Socket instance across internal reconnects.
+     * If we clear registeredSocketEvents without calling socket.off(), the old listeners
+     * remain attached, and registerPendingEventHandlers() adds new ones - causing duplicates.
+     */
+    clearSocketEventListeners() {
+        const { socket } = this;
+        if (!socket)
+            return;
+        for (const event of this.registeredSocketEvents) {
+            socket.off(event);
+        }
+        this.registeredSocketEvents.clear();
+    }
     /**
      * Handle system wake from sleep/hibernate.
      * Re-triggers reconnection if not connected and force reconnect has given up.

package/dist/infra/usecase/connectors-use-case.js

@@ -74,6 +74,9 @@ export class ConnectorsUseCase {
             case 'rules': {
                 return `Agent reads instructions from rule file (${configPath})`;
             }
+            case 'skill': {
+                return `Agent reads skill files from project directory (${configPath})`;
+            }
         }
     }
     /**
@@ -90,6 +93,9 @@ export class ConnectorsUseCase {
             case 'rules': {
                 return 'Rules';
             }
+            case 'skill': {
+                return 'Skill';
+            }
         }
     }
     /**
@@ -136,8 +142,8 @@ export class ConnectorsUseCase {
                 this.terminal.log(`   Installed: ${result.installResult.configPath}`);
             }
             // Show restart message for hook connector
-            if ((result.toType === 'hook' || result.toType === 'mcp') && !result.installResult.alreadyInstalled) {
-                this.terminal.warn(`\nPlease restart ${agent} to apply the new ${result.toType}.`);
+            if (['hook', 'mcp', 'skill'].includes(result.toType) && !result.installResult.alreadyInstalled) {
+                this.terminal.warn(`\n⚠️  Please restart ${agent} to apply the new ${result.toType}.`);
             }
         }
         else {

package/dist/infra/usecase/init-use-case.js

@@ -178,7 +178,7 @@ export class InitUseCase {
                 this.terminal.log(`${selectedAgent} connected via ${defaultType}`);
                 this.terminal.log(`   Installed: ${result.configPath}`);
                 // Show restart message for hook connector
-                if (defaultType === 'hook' || defaultType === 'mcp') {
+                if (['hook', 'mcp', 'skill'].includes(defaultType)) {
                     this.terminal.warn(`\n⚠️  Please restart ${selectedAgent} to apply the new ${defaultType}.`);
                 }
             }

package/dist/infra/usecase/reset-use-case.d.ts

@@ -13,6 +13,7 @@ export declare class ResetUseCase implements IResetUseCase {
     private readonly terminal;
     constructor(options: ResetUseCaseOptions);
     protected confirmReset(): Promise<boolean>;
+    protected deleteContextTree(contextTreeDir: string): Promise<void>;
     run(options: {
         directory?: string;
         skipConfirmation: boolean;

package/dist/infra/usecase/reset-use-case.js

@@ -17,6 +17,9 @@ export class ResetUseCase {
             message: 'Are you sure you want to reset the context tree? This will remove all existing context. Your context tree will be empty.',
         });
     }
+    async deleteContextTree(contextTreeDir) {
+        await rm(contextTreeDir, { force: true, recursive: true });
+    }
     async run(options) {
         try {
             // Check if context tree exists
@@ -36,7 +39,7 @@ export class ResetUseCase {
             // Remove existing context tree directory
             const baseDir = options.directory ?? process.cwd();
             const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
-            await rm(contextTreeDir, { force: true, recursive: true });
+            await this.deleteContextTree(contextTreeDir);
             // Re-initialize empty context tree
             await this.contextTreeService.initialize(options.directory);
             // Re-initialize empty snapshot

package/dist/{commands → oclif/commands}/curate.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { ICurateUseCase } from '../core/interfaces/usecase/i-curate-use-case.js';
+import { ICurateUseCase } from '../../core/interfaces/usecase/i-curate-use-case.js';
 export default class Curate extends Command {
     static args: {
         context: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/{commands → oclif/commands}/curate.js

@@ -1,10 +1,10 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { isDevelopment } from '../config/environment.js';
-import { FileGlobalConfigStore } from '../infra/storage/file-global-config-store.js';
-import { createTokenStore } from '../infra/storage/token-store.js';
-import { OclifTerminal } from '../infra/terminal/oclif-terminal.js';
-import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
-import { CurateUseCase } from '../infra/usecase/curate-use-case.js';
+import { isDevelopment } from '../../config/environment.js';
+import { FileGlobalConfigStore } from '../../infra/storage/file-global-config-store.js';
+import { createTokenStore } from '../../infra/storage/token-store.js';
+import { OclifTerminal } from '../../infra/terminal/oclif-terminal.js';
+import { MixpanelTrackingService } from '../../infra/tracking/mixpanel-tracking-service.js';
+import { CurateUseCase } from '../../infra/usecase/curate-use-case.js';
 export default class Curate extends Command {
     static args = {
         context: Args.string({

package/dist/{commands → oclif/commands}/hook-prompt-submit.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { ITemplateLoader } from '../core/interfaces/i-template-loader.js';
+import { ITemplateLoader } from '../../core/interfaces/i-template-loader.js';
 /**
  * Dependencies required by HookPromptSubmit command.
  * Exported for test mocking.

package/dist/{commands → oclif/commands}/hook-prompt-submit.js

@@ -1,7 +1,7 @@
 import { Command } from '@oclif/core';
-import { isDevelopment } from '../config/environment.js';
-import { FsFileService } from '../infra/file/fs-file-service.js';
-import { FsTemplateLoader } from '../infra/template/fs-template-loader.js';
+import { isDevelopment } from '../../config/environment.js';
+import { FsFileService } from '../../infra/file/fs-file-service.js';
+import { FsTemplateLoader } from '../../infra/template/fs-template-loader.js';
 /**
  * Hidden command for coding agent pre-prompt hooks.
  * Outputs ByteRover workflow instructions to stdout.

package/dist/{commands → oclif/commands}/main.js

@@ -1,15 +1,15 @@
 import { Command } from '@oclif/core';
 import { randomUUID } from 'node:crypto';
-import { DEFAULT_SESSION_RETENTION } from '../core/domain/cipher/session/session-metadata.js';
-import { SessionMetadataStore } from '../infra/cipher/session/session-metadata-store.js';
-import { ProjectConfigStore } from '../infra/config/file-config-store.js';
-import { getProcessManager } from '../infra/process/index.js';
-import { startRepl } from '../infra/repl/repl-startup.js';
-import { FileGlobalConfigStore } from '../infra/storage/file-global-config-store.js';
-import { FileOnboardingPreferenceStore } from '../infra/storage/file-onboarding-preference-store.js';
-import { createTokenStore } from '../infra/storage/token-store.js';
-import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
-import { initSessionLog, processManagerLog } from '../utils/process-logger.js';
+import { DEFAULT_SESSION_RETENTION } from '../../core/domain/cipher/session/session-metadata.js';
+import { SessionMetadataStore } from '../../infra/cipher/session/session-metadata-store.js';
+import { ProjectConfigStore } from '../../infra/config/file-config-store.js';
+import { getProcessManager } from '../../infra/process/index.js';
+import { startRepl } from '../../infra/repl/repl-startup.js';
+import { FileGlobalConfigStore } from '../../infra/storage/file-global-config-store.js';
+import { FileOnboardingPreferenceStore } from '../../infra/storage/file-onboarding-preference-store.js';
+import { createTokenStore } from '../../infra/storage/token-store.js';
+import { MixpanelTrackingService } from '../../infra/tracking/mixpanel-tracking-service.js';
+import { initSessionLog, processManagerLog } from '../../utils/process-logger.js';
 /**
  * Main command - Entry point for ByteRover CLI.
  *

package/dist/{commands → oclif/commands}/mcp.js

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
-import { NoInstanceRunningError } from '../core/domain/errors/connection-error.js';
-import { ByteRoverMcpServer } from '../infra/mcp/index.js';
+import { NoInstanceRunningError } from '../../core/domain/errors/connection-error.js';
+import { ByteRoverMcpServer } from '../../infra/mcp/index.js';
 /**
  * MCP command - starts the MCP server for coding agent integration.
  *

package/dist/{commands → oclif/commands}/query.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { IQueryUseCase } from '../core/interfaces/usecase/i-query-use-case.js';
+import { IQueryUseCase } from '../../core/interfaces/usecase/i-query-use-case.js';
 export default class Query extends Command {
     static args: {
         query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;