byterover-cli 1.4.0 → 1.5.0

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

@@ -27,6 +27,8 @@ import { ProjectConfigStore } from '../config/file-config-store.js';
 import { CurateExecutor } from '../core/executors/curate-executor.js';
 import { QueryExecutor } from '../core/executors/query-executor.js';
 import { createTaskProcessor } from '../core/task-processor.js';
+import { FileProviderConfigStore } from '../storage/file-provider-config-store.js';
+import { ProviderKeychainStore } from '../storage/provider-keychain-store.js';
 import { createTokenStore } from '../storage/token-store.js';
 import { createTransportClient } from '../transport/transport-factory.js';
 import { createParentHeartbeat } from './parent-heartbeat.js';
@@ -44,6 +46,41 @@ function logTransportError(error) {
     const message = error instanceof Error ? error.message : String(error);
     agentLog(`Transport error (non-fatal): ${message}`);
 }
+/**
+ * Send a critical transport event with retry logic.
+ * Uses exponential backoff for retries to handle transient network issues.
+ * Inspired by opencode's robust event forwarding pattern.
+ *
+ * Critical events include: task:completed, task:error, task:cancelled
+ * These should be retried because if they fail, TUI won't know the task ended.
+ *
+ * @param eventName - The event name to send
+ * @param data - The event payload
+ * @param maxRetries - Maximum number of retry attempts (default: 3)
+ */
+function sendCriticalEvent(eventName, data, maxRetries = 3) {
+    const BASE_DELAY_MS = 100;
+    const attemptSend = (attempt) => {
+        transportClient
+            ?.request(eventName, data)
+            .then(() => {
+            // Success - nothing more to do
+        })
+            .catch((error) => {
+            const isLastAttempt = attempt >= maxRetries;
+            const message = error instanceof Error ? error.message : String(error);
+            if (isLastAttempt) {
+                agentLog(`Critical event ${eventName} failed after ${maxRetries + 1} attempts: ${message}`);
+                return;
+            }
+            // Retry with exponential backoff
+            const delay = BASE_DELAY_MS * 2 ** attempt;
+            agentLog(`Critical event ${eventName} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms: ${message}`);
+            setTimeout(() => attemptSend(attempt + 1), delay);
+        });
+    };
+    attemptSend(0);
+}
 // Task types imported from core/domain/transport/schemas.ts:
 // - TaskExecute: Transport → Agent (task:execute event)
 // - TaskCancel: Transport → Agent (task:cancel event)
@@ -345,7 +382,7 @@ function setupTaskExecutor() {
             if (!initialized) {
                 agentLog(`Task ${taskId} rejected - lazy initialization failed`);
                 const error = serializeTaskError(initializationError ?? new AgentNotInitializedError('Agent initialization failed'));
-                transportClient?.request('task:error', { error, taskId }).catch(logTransportError);
+                sendCriticalEvent('task:error', { error, taskId });
                 return;
             }
             agentLog(`Task ${taskId} - lazy initialization successful, proceeding`);
@@ -356,7 +393,7 @@ function setupTaskExecutor() {
         if (!isAgentInitialized || !taskProcessor) {
             agentLog(`Task ${taskId} rejected - agent stopped during queue wait`);
             const error = serializeTaskError(new AgentNotInitializedError('Agent stopped during execution wait'));
-            transportClient?.request('task:error', { error, taskId }).catch(logTransportError);
+            sendCriticalEvent('task:error', { error, taskId });
             return;
         }
         // Track timeout state for error handling
@@ -381,13 +418,13 @@ function setupTaskExecutor() {
             if (timedOut) {
                 agentLog(`Task ${taskId} cancelled due to timeout`);
                 const errorData = serializeTaskError(new Error('Task exceeded 5 minute timeout'));
-                transportClient?.request('task:error', { error: errorData, taskId }).catch(logTransportError);
+                sendCriticalEvent('task:error', { error: errorData, taskId });
                 return;
             }
             // Handle other errors (not timeout)
             agentLog(`Task execution failed: ${error}`);
             const errorData = serializeTaskError(error);
-            transportClient?.request('task:error', { error: errorData, taskId }).catch(logTransportError);
+            sendCriticalEvent('task:error', { error: errorData, taskId });
         }
         finally {
             // Always clear timeout to prevent memory leak
@@ -482,6 +519,118 @@ async function stopExistingAgentForReinit() {
     taskProcessor = undefined;
     isAgentInitialized = false;
 }
+/**
+ * Prepare for reinitialization by draining queue and stopping existing agent.
+ *
+ * NOTE: We do NOT cleanup transport event handlers here because they are meant
+ * to be long-lived for the entire worker process lifecycle. Only agent event
+ * forwarders (which are tied to the CipherAgent instance) are cleaned up via
+ * cleanupAgentEventForwarding() in stopExistingAgentForReinit().
+ */
+async function prepareForReinit() {
+    // Drain task queue before reinit to prevent tasks executing with stale processor
+    agentLog('Draining task queue before reinit...');
+    notifyQueuedTasksAboutDropAndClear('credential/config change');
+    // Wait for active tasks to complete (with timeout)
+    await waitForActiveTasksToComplete(10_000);
+    await stopExistingAgentForReinit();
+}
+/**
+ * Load provider configuration and return API key and model if using external provider.
+ */
+async function loadProviderConfiguration() {
+    const providerConfigStore = new FileProviderConfigStore();
+    const providerKeychainStore = new ProviderKeychainStore();
+    const providerConfig = await providerConfigStore.read();
+    const activeProviderId = providerConfig.activeProvider;
+    // Get OpenRouter API key if using external provider
+    let openRouterApiKey;
+    let modelFromProvider;
+    if (activeProviderId !== 'byterover') {
+        openRouterApiKey = await providerKeychainStore.getApiKey(activeProviderId);
+        modelFromProvider = await providerConfigStore.getActiveModel(activeProviderId);
+        if (openRouterApiKey) {
+            agentLog(`Using external provider: ${activeProviderId}${modelFromProvider ? ` with model: ${modelFromProvider}` : ''}`);
+        }
+    }
+    return { modelFromProvider, openRouterApiKey };
+}
+/**
+ * Build agent configuration object from auth token and provider settings.
+ */
+function buildAgentConfig(authToken, modelFromProvider, openRouterApiKey) {
+    const envConfig = getCurrentConfig();
+    return {
+        accessToken: authToken.accessToken,
+        apiBaseUrl: envConfig.llmApiBaseUrl,
+        fileSystem: { workingDirectory: process.cwd() },
+        llm: {
+            maxIterations: 10,
+            maxTokens: 4096,
+            temperature: 0.7,
+            topK: 10,
+            topP: 0.95,
+            verbose: false,
+        },
+        model: modelFromProvider ?? DEFAULT_LLM_MODEL,
+        openRouterApiKey,
+        projectId: PROJECT,
+        sessionKey: authToken.sessionKey,
+    };
+}
+/**
+ * Initialize agent instance by starting it and creating a session.
+ * Returns the initialized agent or undefined if cleanup was triggered.
+ */
+async function initializeAgentInstance(agent) {
+    // Wrap agent.start() with timeout to prevent isInitializing from getting stuck
+    await withTimeout(agent.start(), AGENT_INIT_TIMEOUT_MS, 'CipherAgent.start()');
+    agentLog('CipherAgent started');
+    // Check if cleanup started during agent.start() (fixes zombie agent race)
+    if (await shouldAbortInitForCleanup(agent, 'agent.start()')) {
+        return undefined;
+    }
+    // Create ChatSession (also with timeout to prevent hanging)
+    chatSessionId = `agent-session-${randomUUID()}`;
+    await withTimeout(agent.createSession(chatSessionId), AGENT_INIT_TIMEOUT_MS, 'CipherAgent.createSession()');
+    agentLog(`ChatSession created: ${chatSessionId}`);
+    // Check if cleanup started during createSession() (fixes zombie agent race)
+    if (await shouldAbortInitForCleanup(agent, 'createSession()')) {
+        return undefined;
+    }
+    return agent;
+}
+/**
+ * Finalize agent initialization by setting up event forwarding, creating task processor,
+ * and updating cached credentials.
+ */
+function finalizeAgentInitialization(params) {
+    const { agent, authToken, brvConfig, curateExecutor, queryExecutor } = params;
+    // Setup event forwarding
+    setupAgentEventForwarding(agent);
+    cipherAgent = agent;
+    // Create TaskProcessor
+    taskProcessor = createTaskProcessor({
+        curateExecutor,
+        queryExecutor,
+    });
+    taskProcessor.setAgent(cipherAgent);
+    // NOTE: setupTaskExecutor() is called once in startAgent() before tryInitializeAgent()
+    // No need to call again here - executor is already set and handles lazy init
+    // Mark as initialized
+    isAgentInitialized = true;
+    initializationError = undefined;
+    // Cache credentials for change detection polling
+    updateCachedCredentials(authToken.accessToken, authToken.sessionKey, brvConfig ? { spaceId: brvConfig.spaceId, teamId: brvConfig.teamId } : undefined);
+    if (brvConfig) {
+        agentLog(`Fully initialized with auth and config (team=${brvConfig.teamId}, space=${brvConfig.spaceId})`);
+    }
+    else {
+        agentLog('Initialized with auth only (no project config yet - will reinit when config available)');
+    }
+    // Broadcast status change to Transport (init success)
+    broadcastStatusChange();
+}
 /**
  * Try to initialize/reinitialize the CipherAgent.
  * Called on startup and lazily when tasks arrive but agent is not initialized.
@@ -516,11 +665,7 @@ async function tryInitializeAgent(forceReinit = false) {
     try {
         // If forcing reinit, drain queue and stop existing agent first
         if (forceReinit) {
-            agentLog('Draining task queue before reinit...');
-            notifyQueuedTasksAboutDropAndClear('credential/config change');
-            // Wait for active tasks to complete (with timeout)
-            await waitForActiveTasksToComplete(10_000);
-            await stopExistingAgentForReinit();
+            await prepareForReinit();
         }
         const tokenStore = createTokenStore();
         const configStore = new ProjectConfigStore();
@@ -534,65 +679,25 @@ async function tryInitializeAgent(forceReinit = false) {
         // Create Executors
         const curateExecutor = new CurateExecutor();
         const queryExecutor = new QueryExecutor();
-        // Initialize CipherAgent
-        const envConfig = getCurrentConfig();
-        const agentConfig = {
-            accessToken: authToken.accessToken,
-            apiBaseUrl: envConfig.llmApiBaseUrl,
-            fileSystem: { workingDirectory: process.cwd() },
-            llm: {
-                maxIterations: 10,
-                maxTokens: 4096,
-                temperature: 0.7,
-                topK: 10,
-                topP: 0.95,
-                verbose: false,
-            },
-            model: DEFAULT_LLM_MODEL,
-            projectId: PROJECT,
-            sessionKey: authToken.sessionKey,
-        };
+        // Read provider configuration
+        const { modelFromProvider, openRouterApiKey } = await loadProviderConfiguration();
+        // Build agent configuration
+        const agentConfig = buildAgentConfig(authToken, modelFromProvider, openRouterApiKey);
+        // Initialize agent instance
         pendingAgent = new CipherAgent(agentConfig, brvConfig ?? undefined);
-        // Wrap agent.start() with timeout to prevent isInitializing from getting stuck
-        await withTimeout(pendingAgent.start(), AGENT_INIT_TIMEOUT_MS, 'CipherAgent.start()');
-        agentLog('CipherAgent started');
-        // Check if cleanup started during agent.start() (fixes zombie agent race)
-        if (await shouldAbortInitForCleanup(pendingAgent, 'agent.start()')) {
-            return false;
-        }
-        // Create ChatSession (also with timeout to prevent hanging)
-        chatSessionId = `agent-session-${randomUUID()}`;
-        await withTimeout(pendingAgent.createSession(chatSessionId), AGENT_INIT_TIMEOUT_MS, 'CipherAgent.createSession()');
-        agentLog(`ChatSession created: ${chatSessionId}`);
-        // Check if cleanup started during createSession() (fixes zombie agent race)
-        if (await shouldAbortInitForCleanup(pendingAgent, 'createSession()')) {
+        const initializedAgent = await initializeAgentInstance(pendingAgent);
+        if (!initializedAgent) {
             return false;
         }
-        // Setup event forwarding
-        setupAgentEventForwarding(pendingAgent);
-        cipherAgent = pendingAgent;
-        pendingAgent = undefined; // Clear local ref - cipherAgent now owns it
-        // Create TaskProcessor
-        taskProcessor = createTaskProcessor({
+        // Finalize initialization
+        finalizeAgentInitialization({
+            agent: initializedAgent,
+            authToken,
+            brvConfig,
             curateExecutor,
             queryExecutor,
         });
-        taskProcessor.setAgent(cipherAgent);
-        // NOTE: setupTaskExecutor() is called once in startAgent() before tryInitializeAgent()
-        // No need to call again here - executor is already set and handles lazy init
-        // Mark as initialized
-        isAgentInitialized = true;
-        initializationError = undefined;
-        // Cache credentials for change detection polling
-        updateCachedCredentials(authToken.accessToken, authToken.sessionKey, brvConfig ? { spaceId: brvConfig.spaceId, teamId: brvConfig.teamId } : undefined);
-        if (brvConfig) {
-            agentLog(`Fully initialized with auth and config (team=${brvConfig.teamId}, space=${brvConfig.spaceId})`);
-        }
-        else {
-            agentLog('Initialized with auth only (no project config yet - will reinit when config available)');
-        }
-        // Broadcast status change to Transport (init success)
-        broadcastStatusChange();
+        pendingAgent = undefined; // Clear local ref - cipherAgent now owns it
         return true;
     }
     catch (error) {
@@ -630,11 +735,11 @@ async function handleTaskExecute(data) {
     if (!taskProcessor) {
         agentLog('TaskProcessor not initialized');
         const error = serializeTaskError(new ProcessorNotInitError());
-        transportClient?.request('task:error', { error, taskId }).catch(logTransportError);
+        sendCriticalEvent('task:error', { error, taskId });
         return;
     }
-    // Notify task started
-    transportClient?.request('task:started', { taskId }).catch(logTransportError);
+    // Notify task started - use sendCriticalEvent for reliability
+    sendCriticalEvent('task:started', { taskId });
     try {
         // Process task - events stream via agentEventBus subscription
         // Response is forwarded via llmservice:response event (no manual send needed)
@@ -649,13 +754,15 @@ async function handleTaskExecute(data) {
             type,
         });
         // Notify completion with result (required by TaskCompletedEventSchema)
+        // Use sendCriticalEvent for retry logic - TUI must know task ended
         agentLog(`Task completed: ${taskId}`);
-        transportClient?.request('task:completed', { result, taskId }).catch(logTransportError);
+        sendCriticalEvent('task:completed', { result, taskId });
     }
     catch (error) {
         const errorData = serializeTaskError(error);
         agentLog(`Task error: ${taskId} - [${errorData.name}] ${errorData.message}`);
-        transportClient?.request('task:error', { error: errorData, taskId }).catch(logTransportError);
+        // Use sendCriticalEvent for retry logic - TUI must know task ended
+        sendCriticalEvent('task:error', { error: errorData, taskId });
     }
 }
 /**
@@ -670,8 +777,8 @@ function handleTaskCancel(data) {
         if (result.wasQueued) {
             // Task was in queue, not yet processing - removed by queue manager
             agentLog(`Task ${taskId} removed from ${result.taskType} queue (was waiting)`);
-            // Notify transport that task was cancelled
-            transportClient?.request('task:cancelled', { taskId }).catch(logTransportError);
+            // Notify transport that task was cancelled - use retry for reliability
+            sendCriticalEvent('task:cancelled', { taskId });
         }
         else {
             // Task is currently processing - cancel via taskProcessor
@@ -733,12 +840,13 @@ async function startAgent() {
         agentLog('Initial setup incomplete - will retry when tasks arrive (lazy init)');
     }
     // Setup event handlers - TaskQueueManager handles queueing and deduplication
+    // These handlers are registered once and persist for the worker's lifetime
     transportClient.on('task:execute', (data) => {
         // Reject tasks during reinit to prevent TOCTOU race condition
         if (isReinitializing) {
             agentLog(`Task ${data.taskId} rejected - agent reinitializing`);
             const error = serializeTaskError(new AgentNotInitializedError('Agent is reinitializing'));
-            transportClient?.request('task:error', { error, taskId: data.taskId }).catch(logTransportError);
+            sendCriticalEvent('task:error', { error, taskId: data.taskId });
             return;
         }
         const result = taskQueueManager.enqueue(data);

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

@@ -42,6 +42,12 @@ export declare class TransportHandlers {
     private agentClientId;
     /** Cached agent status from last status:changed broadcast */
     private cachedAgentStatus;
+    /**
+     * Track recently completed tasks for grace period.
+     * Allows late-arriving llmservice:* events to be routed even after task:completed.
+     * Key: taskId, Value: {task: TaskInfo, completedAt: timestamp}
+     */
+    private completedTasks;
     /** Track active tasks */
     private tasks;
     /** Transport server reference */
@@ -55,6 +61,11 @@ export declare class TransportHandlers {
      * Setup all message handlers.
      */
     setup(): void;
+    /**
+     * Get task info from either active or recently completed tasks.
+     * Returns undefined if task is not found in either map.
+     */
+    private getTaskInfo;
     /**
      * Handle Agent registration.
      * Agent connects as Socket.IO client and sends 'agent:register'.
@@ -70,12 +81,13 @@ export declare class TransportHandlers {
     /**
      * Handle task:cancelled from Agent.
      * Terminal event: task was cancelled before completion.
-     * Route to task owner + broadcast-room, then cleanup.
+     * Route to task owner + broadcast-room, then cleanup with grace period.
      */
     private handleTaskCancelled;
     /**
      * Handle task:completed from Agent.
      * Route directly to task owner + broadcast-room for monitoring.
+     * Uses grace period cleanup to allow late-arriving llmservice:* events.
      */
     private handleTaskCompleted;
     /**
@@ -86,6 +98,7 @@ export declare class TransportHandlers {
     /**
      * Handle task:error from Agent.
      * Route directly to task owner + broadcast-room for monitoring.
+     * Uses grace period cleanup to allow late-arriving llmservice:* events.
      */
     private handleTaskError;
     /**
@@ -93,6 +106,11 @@ export declare class TransportHandlers {
      * Route directly to task owner + broadcast-room for monitoring.
      */
     private handleTaskStarted;
+    /**
+     * Move a task to the completed tasks map with grace period cleanup.
+     * This allows late-arriving llmservice:* events to still be routed.
+     */
+    private moveToCompleted;
     private registerLlmEvent;
     /**
      * Generic handler for routing LLM events from Agent to clients.
@@ -100,9 +118,12 @@ export declare class TransportHandlers {
      *
      * 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)
+     * 2. Check if task is active OR recently completed (within grace period)
+     * 3. Send to task owner + broadcast-room if found
+     * 4. Drop silently if task not found (truly ended beyond grace period)
+     *
+     * The grace period allows late-arriving events (due to network delays or
+     * out-of-order delivery) to still be routed to clients.
      */
     private routeLlmEvent;
     /**

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

@@ -39,6 +39,15 @@ import { isValidTaskType } from '../../utils/type-guards.js';
 // - TaskStartedEvent, TaskCompletedEvent, TaskErrorEvent: Agent → Transport (task lifecycle events)
 // - LlmThinkingEvent, LlmChunkEvent, LlmResponseEvent, etc: Agent → Transport (LLM events)
 // ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Grace period (in ms) to keep completed tasks in memory for late-arriving events.
+ * This prevents silent event drops when llmservice:* events arrive after task:completed.
+ * Inspired by opencode's session callback queuing pattern.
+ */
+const TASK_CLEANUP_GRACE_PERIOD_MS = 5000;
+// ============================================================================
 // Transport Handlers
 // ============================================================================
 /**
@@ -52,6 +61,12 @@ export class TransportHandlers {
     agentClientId;
     /** Cached agent status from last status:changed broadcast */
     cachedAgentStatus;
+    /**
+     * Track recently completed tasks for grace period.
+     * Allows late-arriving llmservice:* events to be routed even after task:completed.
+     * Key: taskId, Value: {task: TaskInfo, completedAt: timestamp}
+     */
+    completedTasks = new Map();
     /** Track active tasks */
     tasks = new Map();
     /** Transport server reference */
@@ -64,6 +79,7 @@ export class TransportHandlers {
      */
     cleanup() {
         this.tasks.clear();
+        this.completedTasks.clear();
         this.agentClientId = undefined;
         this.cachedAgentStatus = undefined;
     }
@@ -76,6 +92,13 @@ export class TransportHandlers {
         this.setupClientHandlers();
         this.setupAgentControlHandlers();
     }
+    /**
+     * Get task info from either active or recently completed tasks.
+     * Returns undefined if task is not found in either map.
+     */
+    getTaskInfo(taskId) {
+        return this.tasks.get(taskId) ?? this.completedTasks.get(taskId)?.task;
+    }
     /**
      * Handle Agent registration.
      * Agent connects as Socket.IO client and sends 'agent:register'.
@@ -119,7 +142,7 @@ export class TransportHandlers {
     /**
      * Handle task:cancelled from Agent.
      * Terminal event: task was cancelled before completion.
-     * Route to task owner + broadcast-room, then cleanup.
+     * Route to task owner + broadcast-room, then cleanup with grace period.
      */
     handleTaskCancelled(data) {
         const { taskId } = data;
@@ -129,11 +152,13 @@ export class TransportHandlers {
             this.transport.sendTo(task.clientId, TransportTaskEventNames.CANCELLED, { taskId });
         }
         this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.CANCELLED, { taskId });
-        this.tasks.delete(taskId);
+        // Move to completed tasks with grace period instead of immediate deletion
+        this.moveToCompleted(taskId);
     }
     /**
      * Handle task:completed from Agent.
      * Route directly to task owner + broadcast-room for monitoring.
+     * Uses grace period cleanup to allow late-arriving llmservice:* events.
      */
     handleTaskCompleted(data) {
         const { result, taskId } = data;
@@ -143,7 +168,9 @@ export class TransportHandlers {
             this.transport.sendTo(task.clientId, TransportTaskEventNames.COMPLETED, { result, taskId });
         }
         this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.COMPLETED, { result, taskId });
-        this.tasks.delete(taskId);
+        // Move to completed tasks with grace period instead of immediate deletion
+        // This allows late-arriving llmservice:* events to still be routed
+        this.moveToCompleted(taskId);
     }
     /**
      * Handle task:create request from client.
@@ -221,6 +248,7 @@ export class TransportHandlers {
     /**
      * Handle task:error from Agent.
      * Route directly to task owner + broadcast-room for monitoring.
+     * Uses grace period cleanup to allow late-arriving llmservice:* events.
      */
     handleTaskError(data) {
         const { error, taskId } = data;
@@ -230,7 +258,8 @@ export class TransportHandlers {
             this.transport.sendTo(task.clientId, TransportTaskEventNames.ERROR, { error, taskId });
         }
         this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.ERROR, { error, taskId });
-        this.tasks.delete(taskId);
+        // Move to completed tasks with grace period instead of immediate deletion
+        this.moveToCompleted(taskId);
     }
     /**
      * Handle task:started from Agent.
@@ -257,6 +286,21 @@ export class TransportHandlers {
             this.transport.broadcastTo('broadcast-room', TransportTaskEventNames.STARTED, { taskId });
         }
     }
+    /**
+     * Move a task to the completed tasks map with grace period cleanup.
+     * This allows late-arriving llmservice:* events to still be routed.
+     */
+    moveToCompleted(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+            this.completedTasks.set(taskId, { completedAt: Date.now(), task });
+            this.tasks.delete(taskId);
+            // Schedule cleanup after grace period
+            setTimeout(() => {
+                this.completedTasks.delete(taskId);
+            }, TASK_CLEANUP_GRACE_PERIOD_MS);
+        }
+    }
     registerLlmEvent(eventName) {
         this.transport.onRequest(eventName, (data) => {
             this.routeLlmEvent(eventName, data);
@@ -268,15 +312,18 @@ export class TransportHandlers {
      *
      * 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)
+     * 2. Check if task is active OR recently completed (within grace period)
+     * 3. Send to task owner + broadcast-room if found
+     * 4. Drop silently if task not found (truly ended beyond grace period)
+     *
+     * The grace period allows late-arriving events (due to network delays or
+     * out-of-order delivery) to still be routed to clients.
      */
     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
+        // Use getTaskInfo to check both active and recently completed tasks
+        const task = this.getTaskInfo(taskId);
+        // Guard: Drop events for tasks not found in either active or completed maps
         if (!task) {
             return;
         }

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

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

package/dist/infra/repl/commands/index.js

@@ -3,7 +3,9 @@ import { curateCommand } from './curate-command.js';
 import { initCommand } from './init-command.js';
 import { loginCommand } from './login-command.js';
 import { logoutCommand } from './logout-command.js';
+import { modelCommand } from './model-command.js';
 import { newCommand } from './new-command.js';
+import { providerCommand } from './provider-command.js';
 import { pullCommand } from './pull-command.js';
 import { pushCommand } from './push-command.js';
 import { queryCommand } from './query-command.js';
@@ -23,6 +25,9 @@ export const load = () => [
     queryCommand, // Query context tree
     // Connectors management
     connectorsCommand, // Manage agent connectors (rules/hook)
+    // Provider management
+    providerCommand, // Connect to LLM providers
+    modelCommand, // Select model from provider
     // Sync operations
     pushCommand, // Push to cloud
     pullCommand, // Pull from cloud

package/dist/infra/repl/commands/model-command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Model Command
+ *
+ * Interactive command for selecting LLM models from the active provider.
+ * Uses the streaming command pattern with inline prompts.
+ *
+ * Usage: /model
+ */
+import type { SlashCommand } from '../../../tui/types.js';
+/**
+ * Model command definition.
+ */
+export declare const modelCommand: SlashCommand;