byterover-cli 3.10.3 → 3.12.0

package/dist/server/infra/process/task-router.d.ts

@@ -19,6 +19,7 @@ import type { IAgentPool } from '../../core/interfaces/agent/i-agent-pool.js';
 import type { ITaskLifecycleHook } from '../../core/interfaces/process/i-task-lifecycle-hook.js';
 import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
 import type { IProjectRouter } from '../../core/interfaces/routing/i-project-router.js';
+import type { ITaskHistoryStore } from '../../core/interfaces/storage/i-task-history-store.js';
 import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
 import type { TaskInfo } from './types.js';
 /**
@@ -47,6 +48,13 @@ type TaskRouterOptions = {
     agentPool?: IAgentPool;
     /** Function to resolve agent clientId for a given project */
     getAgentForProject: (projectPath?: string) => string | undefined;
+    /**
+     * Per-project `ITaskHistoryStore` factory (DIP). When omitted, the new
+     * persistent-history handlers (`task:list` paginated, `task:get`,
+     * `task:delete*`, `task:clearCompleted`) gracefully degrade to in-memory
+     * only — keeping pre-M2.09 unit tests unaffected.
+     */
+    getTaskHistoryStore?: (projectPath: string) => ITaskHistoryStore;
     /** Resolves project's review-disabled flag at task-create. Optional; missing → undefined → enabled. */
     isReviewDisabled?: IsReviewDisabledResolver;
     /** Lifecycle hooks for task events (e.g. CurateLogHandler). */
@@ -61,23 +69,43 @@ type TaskRouterOptions = {
     preDispatchCheck?: PreDispatchCheck;
     projectRegistry?: IProjectRegistry;
     projectRouter?: IProjectRouter;
+    /**
+     * Resolves the active provider/model snapshot at task-create time.
+     * Failures are swallowed (fail-open) so dispatch is never blocked.
+     */
+    resolveActiveProvider?: () => Promise<{
+        model?: string;
+        provider?: string;
+    }>;
     /** Resolves the projectPath a client registered with (from client:register). */
     resolveClientProjectPath?: (clientId: string) => string | undefined;
     transport: ITransportServer;
 };
 export declare class TaskRouter {
+    /**
+     * Throttle window for `onTaskUpdate` flushes — bursts of llmservice events
+     * are coalesced into one save per window. 100ms keeps perceived latency low
+     * while bounding write volume on chatty multi-step agents.
+     */
+    private static readonly FLUSH_INTERVAL_MS;
     private readonly agentPool;
     /**
      * Track recently completed tasks for grace period.
      * Allows late-arriving llmservice:* events to be routed even after task:completed.
      */
     private completedTasks;
+    /** TaskIds with pending in-flight mutations awaiting the next throttled flush. */
+    private readonly dirtyTaskIds;
+    /** Pending throttle timer, if any. */
+    private flushTimer;
     private readonly getAgentForProject;
+    private readonly getTaskHistoryStore;
     private readonly isReviewDisabled;
     private readonly lifecycleHooks;
     private readonly preDispatchCheck;
     private readonly projectRegistry;
     private readonly projectRouter;
+    private readonly resolveActiveProvider;
     private readonly resolveClientProjectPath;
     /** Track active tasks */
     private tasks;
@@ -117,8 +145,37 @@ export declare class TaskRouter {
      * Register all task and LLM event handlers on the transport.
      */
     setup(): void;
+    /**
+     * Mutate the live `TaskInfo` from an `llmservice:*` event so a tab refresh
+     * during the throttle window sees the in-flight state. Each branch:
+     *   - thinking: push a `{isThinking: true, content: ''}` marker
+     *   - chunk(reasoning): append to last item / flip empty marker / push fresh
+     *   - chunk(text): IGNORED for persistence (transient stream)
+     *   - response: set responseContent + sessionId (overwrite — multi-step keeps latest)
+     *   - toolCall: push running entry
+     *   - toolResult: update existing entry by callId
+     *   - error / unsupportedInput: IGNORED (terminal hooks capture failure)
+     *
+     * Mutations use immutable `tasks.set(id, {...task, ...delta})` so consumers
+     * holding a captured reference (e.g. notifyHooks*) see a stable snapshot.
+     */
+    private accumulateLlmEvent;
+    /**
+     * Emit `task:deleted` to the project room when a task is removed. Skips
+     * silently when no projectPath is resolvable (broadcast wouldn't reach
+     * any room). Clients that miss the broadcast will simply not see a row
+     * disappear; they reconcile on next `task:list`.
+     */
+    private broadcastTaskDeleted;
+    /**
+     * Drain the dirty set: for each taskId still active, fire `onTaskUpdate` on
+     * each lifecycle hook. Tasks moved to `completedTasks` between markDirty
+     * and flush are skipped — their terminal lifecycle hook already saved.
+     */
+    private flushDirty;
     private handleTaskCancel;
     private handleTaskCancelled;
+    private handleTaskClearCompleted;
     private handleTaskCompleted;
     /**
      * Handle task creation from a client.
@@ -134,7 +191,10 @@ export declare class TaskRouter {
      * 6. Submit to agentPool (fire-and-forget)
      */
     private handleTaskCreate;
+    private handleTaskDelete;
+    private handleTaskDeleteBulk;
     private handleTaskError;
+    private handleTaskGet;
     private handleTaskList;
     /**
      * Emit `task:completed` for a task that the daemon's pre-dispatch gate skipped
@@ -153,6 +213,12 @@ export declare class TaskRouter {
      */
     private handleTaskSkippedByPreCheck;
     private handleTaskStarted;
+    /**
+     * Mark a taskId for the next throttled `onTaskUpdate` flush.
+     * Schedules a timer if none is pending. Bursts of dirty marks within the
+     * 100ms window coalesce into a single flush.
+     */
+    private markDirty;
     /**
      * Move a task to the completed tasks map with grace period cleanup.
      */
@@ -188,6 +254,12 @@ export declare class TaskRouter {
      * Each hook is called independently; errors are caught and logged.
      */
     private runCreateHooks;
+    /**
+     * Invoke `resolveActiveProvider` with a try/catch so a thrown resolver
+     * cannot block task dispatch. Returns `{}` when no resolver is configured
+     * or when the resolver rejects/throws.
+     */
+    private safeResolveActiveProvider;
     /**
      * Reads the project's reviewDisabled flag at task-create.
      *