byterover-cli 3.11.0 → 3.12.0

package/dist/shared/transport/events/index.d.ts

@@ -146,10 +146,15 @@ export declare const AllEventGroups: readonly [{
     readonly ACK: "task:ack";
     readonly CANCEL: "task:cancel";
     readonly CANCELLED: "task:cancelled";
+    readonly CLEAR_COMPLETED: "task:clearCompleted";
     readonly COMPLETED: "task:completed";
     readonly CREATE: "task:create";
     readonly CREATED: "task:created";
+    readonly DELETE: "task:delete";
+    readonly DELETE_BULK: "task:deleteBulk";
+    readonly DELETED: "task:deleted";
     readonly ERROR: "task:error";
+    readonly GET: "task:get";
     readonly LIST: "task:list";
     readonly STARTED: "task:started";
 }, {

package/dist/shared/transport/events/task-events.d.ts

@@ -1,11 +1,22 @@
+/**
+ * Persisted-entry schema version. Bumped only on shape-breaking changes to
+ * `TaskHistoryEntry`. The Zod schema in `server/core/domain/entities/` uses
+ * `z.literal(TASK_HISTORY_SCHEMA_VERSION)` to refuse mismatched on-disk lines.
+ */
+export declare const TASK_HISTORY_SCHEMA_VERSION = 1;
 export declare const TaskEvents: {
     readonly ACK: "task:ack";
     readonly CANCEL: "task:cancel";
     readonly CANCELLED: "task:cancelled";
+    readonly CLEAR_COMPLETED: "task:clearCompleted";
     readonly COMPLETED: "task:completed";
     readonly CREATE: "task:create";
     readonly CREATED: "task:created";
+    readonly DELETE: "task:delete";
+    readonly DELETE_BULK: "task:deleteBulk";
+    readonly DELETED: "task:deleted";
     readonly ERROR: "task:error";
+    readonly GET: "task:get";
     readonly LIST: "task:list";
     readonly STARTED: "task:started";
 };
@@ -30,6 +41,33 @@ export interface TaskCancelResponse {
     success: boolean;
 }
 export type TaskListItemStatus = 'cancelled' | 'completed' | 'created' | 'error' | 'started';
+/**
+ * Reasoning/thinking content item with timestamp for ordering.
+ * Shared between webui, tui, and the server-side TaskHistoryEntry.
+ */
+export type ReasoningContentItem = {
+    content: string;
+    /** Whether this reasoning item is still being streamed */
+    isThinking?: boolean;
+    timestamp: number;
+};
+/**
+ * Persisted tool-call lifecycle entry — distinct from the wire-payload
+ * `LlmToolCallEventSchema` in `core/domain/transport/schemas.ts`. This shape
+ * carries the `running | completed | error` state machine and is the form
+ * stored in `TaskHistoryEntry.toolCalls`.
+ */
+export type ToolCallEvent = {
+    args: Record<string, unknown>;
+    callId?: string;
+    error?: string;
+    errorType?: string;
+    result?: unknown;
+    sessionId: string;
+    status: 'completed' | 'error' | 'running';
+    timestamp: number;
+    toolName: string;
+};
 export interface TaskListItem {
     completedAt?: number;
     content: string;
@@ -37,22 +75,187 @@ export interface TaskListItem {
     error?: {
         code?: string;
         message: string;
-        name?: string;
+        name: string;
     };
     /** Optional file paths from `curate --files` */
     files?: string[];
     /** Folder path for `curate-folder` tasks */
     folderPath?: string;
+    /** Active model id at task creation time */
+    model?: string;
     projectPath?: string;
+    /** Active provider id at task creation time */
+    provider?: string;
     result?: string;
     startedAt?: number;
     status: TaskListItemStatus;
     taskId: string;
     type: string;
 }
+/**
+ * task:list request — numbered pagination + filter/search (M2.16).
+ * All filter dims are optional; AND-combined when multiple are set.
+ */
 export interface TaskListRequest {
+    /** createdAt >= this epoch ms */
+    createdAfter?: number;
+    /** createdAt <= this epoch ms */
+    createdBefore?: number;
+    /** Maximum elapsed time (ms) for terminal tasks. */
+    maxDurationMs?: number;
+    /** Minimum elapsed time (ms); only matches startedAt+completedAt rows. */
+    minDurationMs?: number;
+    /** Filter to these model ids (exact match). */
+    model?: string[];
+    /** 1-based page index; defaults to 1. */
+    page?: number;
+    /** Page size 1..1000; defaults to 50. */
+    pageSize?: number;
     projectPath?: string;
+    /** Filter to these provider ids (exact match). */
+    provider?: string[];
+    /** Case-insensitive substring on content + result + error.message. */
+    searchText?: string;
+    status?: TaskListItemStatus[];
+    type?: string[];
+}
+/** Status histogram used by FE filter-bar breakdown (M2.16). */
+export interface TaskListCounts {
+    all: number;
+    cancelled: number;
+    completed: number;
+    /** Tasks with status === 'error'. */
+    failed: number;
+    /** Tasks with status === 'created' || 'started'. */
+    running: number;
+}
+/** (providerId, modelId) pair from history (M2.16). */
+export interface TaskListAvailableModel {
+    modelId: string;
+    providerId: string;
 }
 export interface TaskListResponse {
+    /** Distinct (providerId, modelId) pairs seen in candidate set. */
+    availableModels: TaskListAvailableModel[];
+    /** Distinct providerId values seen in candidate set. */
+    availableProviders: string[];
+    /**
+     * Status histogram matching current filter scope (Model A — post-filter).
+     * `counts.all === total` invariant. When user picks `status: ['error']`,
+     * `counts.failed === total` and other buckets are 0.
+     */
+    counts: TaskListCounts;
+    /**
+     * 1-based page index, echoed back as-sent. Server clamps the LOWER bound
+     * (page < 1 → 1) but does NOT clamp against `pageCount`. A request with
+     * `page=9999` against a 1-page result returns `page: 9999, tasks: []` so
+     * the caller can detect an out-of-range page.
+     */
+    page: number;
+    /** ceil(total / pageSize), min 1. */
+    pageCount: number;
+    /** Page size echoed back, clamped to [1, 1000]. */
+    pageSize: number;
     tasks: TaskListItem[];
+    /** Total items matching ALL filters (incl. status). */
+    total: number;
 }
+export type TaskClearCompletedRequest = {
+    projectPath?: string;
+};
+export type TaskClearCompletedResponse = {
+    deletedCount: number;
+    error?: string;
+};
+export type TaskDeleteBulkRequest = {
+    taskIds: string[];
+};
+export type TaskDeleteBulkResponse = {
+    deletedCount: number;
+    error?: string;
+};
+export type TaskDeleteRequest = {
+    taskId: string;
+};
+export type TaskDeleteResponse = {
+    error?: string;
+    /**
+     * `true` when the task was actually removed (was live or persisted),
+     * `false` when the call was a no-op (taskId unknown or already tombstoned).
+     * `task:deleteBulk` uses this to compute an accurate `deletedCount`.
+     */
+    removed?: boolean;
+    success: boolean;
+};
+export type TaskDeletedEvent = {
+    taskId: string;
+};
+export type TaskGetRequest = {
+    taskId: string;
+};
+export type TaskGetResponse = {
+    task: null | TaskHistoryEntry;
+};
+/**
+ * Full per-task error payload — superset of `TaskListItem.error`, adds the
+ * optional `details` bag. Mirrors `TaskErrorDataSchema` in
+ * `src/server/core/domain/entities/task-history-entry.ts`; the server schema
+ * carries `satisfies z.ZodType<TaskErrorData>` to keep them aligned.
+ */
+export type TaskErrorData = {
+    code?: string;
+    details?: Record<string, unknown>;
+    message: string;
+    name: string;
+};
+/**
+ * Discriminated-union shape for a persisted task. The server-side Zod schema
+ * (`TaskHistoryEntrySchema`) is the runtime source of truth and carries
+ * `satisfies z.ZodType<TaskHistoryEntry>` so any drift between the two
+ * representations is a typecheck error.
+ *
+ * Lives in `shared/` so webui + tui can consume it without inverting the
+ * dependency direction onto `server/`.
+ */
+type TaskHistoryEntryBase = {
+    clientCwd?: string;
+    content: string;
+    createdAt: number;
+    files?: string[];
+    folderPath?: string;
+    id: string;
+    logId?: string;
+    model?: string;
+    projectPath: string;
+    provider?: string;
+    reasoningContents?: ReasoningContentItem[];
+    responseContent?: string;
+    schemaVersion: typeof TASK_HISTORY_SCHEMA_VERSION;
+    sessionId?: string;
+    taskId: string;
+    toolCalls?: ToolCallEvent[];
+    type: string;
+    worktreeRoot?: string;
+};
+export type TaskHistoryEntry = (TaskHistoryEntryBase & {
+    completedAt: number;
+    error: TaskErrorData;
+    startedAt?: number;
+    status: 'error';
+}) | (TaskHistoryEntryBase & {
+    completedAt: number;
+    result?: string;
+    startedAt?: number;
+    status: 'completed';
+}) | (TaskHistoryEntryBase & {
+    completedAt: number;
+    startedAt?: number;
+    status: 'cancelled';
+}) | (TaskHistoryEntryBase & {
+    startedAt: number;
+    status: 'started';
+}) | (TaskHistoryEntryBase & {
+    status: 'created';
+});
+export type TaskHistoryStatus = TaskHistoryEntry['status'];
+export {};

package/dist/shared/transport/events/task-events.js

@@ -1,11 +1,22 @@
+/**
+ * Persisted-entry schema version. Bumped only on shape-breaking changes to
+ * `TaskHistoryEntry`. The Zod schema in `server/core/domain/entities/` uses
+ * `z.literal(TASK_HISTORY_SCHEMA_VERSION)` to refuse mismatched on-disk lines.
+ */
+export const TASK_HISTORY_SCHEMA_VERSION = 1;
 export const TaskEvents = {
     ACK: 'task:ack',
     CANCEL: 'task:cancel',
     CANCELLED: 'task:cancelled',
+    CLEAR_COMPLETED: 'task:clearCompleted',
     COMPLETED: 'task:completed',
     CREATE: 'task:create',
     CREATED: 'task:created',
+    DELETE: 'task:delete',
+    DELETE_BULK: 'task:deleteBulk',
+    DELETED: 'task:deleted',
     ERROR: 'task:error',
+    GET: 'task:get',
     LIST: 'task:list',
     STARTED: 'task:started',
 };

package/dist/tui/features/tasks/hooks/use-task-subscriptions.js

@@ -23,6 +23,13 @@ export function useTaskSubscriptions() {
             store.setError(data.taskId, data.error);
         }), client.on('task:cancelled', (data) => {
             store.setCancelled(data.taskId);
+        }), 
+        // task:deleted is broadcast by the daemon when ANY client (this TUI, the
+        // WebUI, or another tab) removes a task via task:delete /
+        // task:deleteBulk / task:clearCompleted. Drop the row locally so all
+        // surfaces stay in sync without polling.
+        client.on('task:deleted', (data) => {
+            store.removeTask(data.taskId);
         }), client.on('llmservice:toolCall', (data) => {
             if (!data.taskId)
                 return;

package/dist/tui/features/tasks/stores/tasks-store.d.ts

@@ -4,24 +4,10 @@
  * Zustand store for task lifecycle state.
  * Subscribes to task:* and llmservice:* transport events.
  */
+import type { ReasoningContentItem, ToolCallEvent } from '../../../../shared/transport/events/task-events.js';
 import type { TaskStats } from '../../../types/ui.js';
 export type TaskStatus = 'cancelled' | 'completed' | 'created' | 'error' | 'started';
-export interface ToolCallEvent {
-    args: Record<string, unknown>;
-    callId?: string;
-    error?: string;
-    errorType?: string;
-    result?: unknown;
-    sessionId: string;
-    status: 'completed' | 'error' | 'running';
-    timestamp: number;
-    toolName: string;
-}
-export interface ReasoningContentItem {
-    content: string;
-    isThinking?: boolean;
-    timestamp: number;
-}
+export type { ReasoningContentItem, ToolCallEvent } from '../../../../shared/transport/events/task-events.js';
 export interface TaskErrorData {
     code?: string;
     message: string;
@@ -76,6 +62,8 @@ export interface TasksActions {
     createTask: (taskId: string, type: 'curate' | 'query', content: string, files?: string[]) => void;
     /** Get a task by ID */
     getTask: (taskId: string) => Task | undefined;
+    /** Remove a task from local state (driven by `task:deleted` broadcast). */
+    removeTask: (taskId: string) => void;
     /** Set task to cancelled */
     setCancelled: (taskId: string) => void;
     /** Set task to completed with result */

package/dist/tui/features/tasks/stores/tasks-store.js

@@ -127,6 +127,13 @@ export const useTasksStore = create()((set, get) => ({
         return { stats: computeStats(tasks), tasks };
     }),
     getTask: (taskId) => get().tasks.get(taskId),
+    removeTask: (taskId) => set((state) => {
+        if (!state.tasks.has(taskId))
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.delete(taskId);
+        return { stats: computeStats(tasks), tasks };
+    }),
     setCancelled: (taskId) => set((state) => {
         const task = state.tasks.get(taskId);
         if (!task) {

package/dist/tui/types/messages.d.ts

@@ -1,6 +1,7 @@
 /**
  * Message and activity log types
  */
+import type { ReasoningContentItem } from '../../shared/transport/events/task-events.js';
 /**
  * Status of an execution (curate/query job)
  */
@@ -54,15 +55,7 @@ export interface ToolProgressItem {
     /** Tool name */
     toolCallName: string;
 }
-/**
- * Reasoning content item with timestamp for sorting
- */
-export interface ReasoningContentItem {
-    content: string;
-    /** Whether this reasoning item is still being streamed */
-    isThinking?: boolean;
-    timestamp: number;
-}
+export type { ReasoningContentItem } from '../../shared/transport/events/task-events.js';
 /**
  * Activity log item for displaying in logs view
  */