byterover-cli 1.0.4 → 1.1.0

package/dist/infra/cipher/session/chat-session.d.ts

@@ -23,7 +23,11 @@ import { SessionEventBus } from '../events/event-emitter.js';
 export declare class ChatSession implements IChatSession {
     readonly eventBus: SessionEventBus;
     readonly id: string;
+    /** Map of taskId -> AbortController for concurrent task cancellation */
+    private readonly activeControllers;
+    /** Fallback controller for non-task executions (interactive mode) */
     private currentController?;
+    /** Fallback taskId for non-task executions - DEPRECATED: use activeControllers */
     private currentTaskId?;
     private readonly forwarders;
     private isExecuting;
@@ -39,9 +43,10 @@ export declare class ChatSession implements IChatSession {
      */
     constructor(id: string, sharedServices: CipherAgentServices, sessionServices: SessionServices);
     /**
-     * Cancel the current operation.
+     * Cancel the current operation or a specific task.
+     * @param taskId - Optional taskId to cancel specific task, otherwise cancels fallback controller
      */
-    cancel(): void;
+    cancel(taskId?: string): void;
     /**
      * Cleanup session resources but preserve history for later restoration.
      * Call this when ending a session temporarily (e.g., user navigates away).

package/dist/infra/cipher/session/chat-session.js

@@ -36,7 +36,11 @@ const SESSION_EVENT_NAMES = [
 export class ChatSession {
     eventBus;
     id;
+    /** Map of taskId -> AbortController for concurrent task cancellation */
+    activeControllers = new Map();
+    /** Fallback controller for non-task executions (interactive mode) */
     currentController;
+    /** Fallback taskId for non-task executions - DEPRECATED: use activeControllers */
     currentTaskId;
     forwarders = new Map();
     isExecuting = false;
@@ -60,10 +64,18 @@ export class ChatSession {
         this.setupEventForwarding();
     }
     /**
-     * Cancel the current operation.
+     * Cancel the current operation or a specific task.
+     * @param taskId - Optional taskId to cancel specific task, otherwise cancels fallback controller
      */
-    cancel() {
-        if (this.currentController) {
+    cancel(taskId) {
+        if (taskId) {
+            const controller = this.activeControllers.get(taskId);
+            if (controller) {
+                controller.abort();
+                this.activeControllers.delete(taskId);
+            }
+        }
+        else if (this.currentController) {
             this.currentController.abort();
         }
     }
@@ -73,7 +85,12 @@ export class ChatSession {
      * History remains in ContextManager for persistence; event listeners stay for potential reactivation.
      */
     cleanup() {
-        // Cancel any in-flight operation
+        // Cancel all active task controllers
+        for (const controller of this.activeControllers.values()) {
+            controller.abort();
+        }
+        this.activeControllers.clear();
+        // Cancel fallback controller
         if (this.currentController) {
             this.currentController.abort();
             this.currentController = undefined;
@@ -154,44 +171,55 @@ export class ChatSession {
      * @param options.taskId - Optional task ID for concurrent task isolation
      */
     async run(input, options) {
-        // Create abort controller for cancellation
-        this.currentController = new AbortController();
+        const taskId = options?.taskId;
+        const controller = new AbortController();
+        // Track controller per-task for concurrent execution support
+        if (taskId) {
+            this.activeControllers.set(taskId, controller);
+        }
+        else {
+            this.currentController = controller;
+        }
+        // Store taskId for event forwarding (last-write-wins for concurrent tasks)
+        this.currentTaskId = taskId;
         this.isExecuting = true;
-        // Store taskId for event forwarding
-        this.currentTaskId = options?.taskId;
-        // Update session status to busy
         sessionStatusManager.setBusy(this.id, this.eventBus);
-        // Store reference to controller for use in catch/finally blocks
-        // This prevents race conditions where currentController might be undefined
-        const controller = this.currentController;
         try {
-            // Process any queued messages first, coalescing with current input
-            const queued = this.messageQueue.dequeueAll();
-            const finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
-            // Delegate to service - it handles everything
-            // Pass taskId for billing tracking
+            let finalInput = input;
+            if (!taskId) {
+                const queued = this.messageQueue.dequeueAll();
+                finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
+            }
             const response = await this.llmService.completeTask(finalInput, {
                 executionContext: options?.executionContext,
                 signal: controller.signal,
-                taskId: options?.taskId,
+                taskId,
             });
             return response;
         }
         catch (error) {
-            // Check if cancelled - use stored controller reference to avoid undefined access
             if (controller.signal.aborted) {
                 throw new SessionCancelledError(this.id);
             }
-            // Wrap other errors - pass message as-is since it's already formatted
             const errorMessage = error instanceof Error ? error.message : String(error);
             throw new LLMError(errorMessage, this.id);
         }
         finally {
-            this.isExecuting = false;
-            this.currentController = undefined;
-            this.currentTaskId = undefined;
-            // Update session status back to idle
-            sessionStatusManager.setIdle(this.id, this.eventBus);
+            if (taskId) {
+                this.activeControllers.delete(taskId);
+            }
+            else {
+                this.currentController = undefined;
+            }
+            // Clear taskId if this was the active one
+            if (this.currentTaskId === taskId) {
+                this.currentTaskId = undefined;
+            }
+            // Only mark idle if no active tasks
+            if (this.activeControllers.size === 0) {
+                this.isExecuting = false;
+                sessionStatusManager.setIdle(this.id, this.eventBus);
+            }
         }
     }
     /**
@@ -232,36 +260,38 @@ export class ChatSession {
      */
     async streamRun(input, options) {
         const startTime = Date.now();
+        const taskId = options?.taskId;
+        const controller = new AbortController();
         let finishReason = 'stop';
         let error;
-        // Create abort controller for cancellation
-        this.currentController = new AbortController();
+        // Track controller per-task for concurrent execution support
+        if (taskId) {
+            this.activeControllers.set(taskId, controller);
+        }
+        else {
+            this.currentController = controller;
+        }
+        // Store taskId for event forwarding (last-write-wins for concurrent tasks)
+        this.currentTaskId = taskId;
         this.isExecuting = true;
-        // Store taskId for event forwarding
-        this.currentTaskId = options?.taskId;
-        // Update session status to busy
         sessionStatusManager.setBusy(this.id, this.eventBus);
-        // Store reference to controller for use in catch/finally blocks
-        // This prevents race conditions where currentController might be undefined
-        const controller = this.currentController;
-        // Link external signal if provided (use {once: true} to prevent listener accumulation)
+        // Link external signal if provided
         if (options?.signal) {
-            options.signal.addEventListener('abort', () => controller?.abort(), { once: true });
+            options.signal.addEventListener('abort', () => controller.abort(), { once: true });
         }
         try {
-            // Process any queued messages first, coalescing with current input
-            const queued = this.messageQueue.dequeueAll();
-            const finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
-            // Delegate to service - it handles everything and emits events
-            // Pass taskId for billing tracking
+            let finalInput = input;
+            if (!taskId) {
+                const queued = this.messageQueue.dequeueAll();
+                finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
+            }
             await this.llmService.completeTask(finalInput, {
                 executionContext: options?.executionContext,
                 signal: controller.signal,
-                taskId: options?.taskId,
+                taskId,
             });
         }
         catch (error_) {
-            // Check if cancelled - use stored controller reference to avoid undefined access
             if (controller.signal.aborted) {
                 finishReason = 'cancelled';
             }
@@ -271,21 +301,29 @@ export class ChatSession {
             }
         }
         finally {
-            this.isExecuting = false;
-            this.currentController = undefined;
-            // Save taskId before clearing for run:complete event
-            const completedTaskId = this.currentTaskId;
-            this.currentTaskId = undefined;
-            // Update session status back to idle
-            sessionStatusManager.setIdle(this.id, this.eventBus);
-            // Emit run:complete event with taskId for billing tracking
+            if (taskId) {
+                this.activeControllers.delete(taskId);
+            }
+            else {
+                this.currentController = undefined;
+            }
+            // Clear taskId if this was the active one
+            if (this.currentTaskId === taskId) {
+                this.currentTaskId = undefined;
+            }
+            // Only mark idle if no active tasks
+            if (this.activeControllers.size === 0) {
+                this.isExecuting = false;
+                sessionStatusManager.setIdle(this.id, this.eventBus);
+            }
+            // Emit run:complete event with taskId
             const durationMs = Date.now() - startTime;
             this.eventBus.emit('run:complete', {
                 durationMs,
                 error,
                 finishReason,
-                stepCount: 0, // Can be enhanced later to track actual step count
-                ...(completedTaskId && { taskId: completedTaskId }),
+                stepCount: 0,
+                ...(taskId && { taskId }),
             });
         }
     }

package/dist/infra/cipher/session/session-metadata-store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * SessionMetadataStore - Manages session metadata persistence.
+ *
+ * Stores session metadata in .brv/sessions/ directory:
+ * - active.json: Current active session pointer
+ * - session-*.json: Individual session metadata files
+ *
+ * Design adapted from gemini-cli's ChatRecordingService pattern.
+ */
+import type { ISessionPersistence, SessionCleanupResult, SessionRetentionConfig } from '../../../core/interfaces/cipher/i-session-persistence.js';
+import { type ActiveSessionPointer, type SessionInfo, type SessionMetadata } from '../../../core/domain/cipher/session/session-metadata.js';
+/**
+ * SessionMetadataStore implementation.
+ *
+ * Manages session metadata stored in .brv/sessions/ directory.
+ */
+export declare class SessionMetadataStore implements ISessionPersistence {
+    private readonly activeSessionPath;
+    private readonly sessionsDir;
+    private readonly workingDirectory;
+    /**
+     * Create a new SessionMetadataStore.
+     *
+     * @param workingDirectory - Project working directory (defaults to process.cwd())
+     */
+    constructor(workingDirectory?: string);
+    cleanupSessions(config: SessionRetentionConfig): Promise<SessionCleanupResult>;
+    clearActiveSession(): Promise<void>;
+    /**
+     * Create a new session metadata object.
+     *
+     * @param sessionId - Session ID
+     * @returns New session metadata with defaults
+     */
+    createSessionMetadata(sessionId: string): SessionMetadata;
+    deleteSession(sessionId: string): Promise<boolean>;
+    getActiveSession(): Promise<ActiveSessionPointer | null>;
+    getSession(sessionId: string): Promise<null | SessionMetadata>;
+    isActiveSessionStale(): Promise<boolean>;
+    isSessionForCurrentProject(sessionId: string): Promise<boolean>;
+    listSessions(): Promise<SessionInfo[]>;
+    markSessionEnded(sessionId: string): Promise<void>;
+    markSessionInterrupted(sessionId: string): Promise<void>;
+    saveSession(metadata: SessionMetadata): Promise<void>;
+    setActiveSession(sessionId: string): Promise<void>;
+    setSessionTitle(sessionId: string, title: string): Promise<void>;
+    updateSessionActivity(sessionId: string, messageCount: number): Promise<void>;
+    /**
+     * Ensure the sessions directory exists.
+     */
+    private ensureSessionsDir;
+}