@crewx/sdk 0.9.0-rc.18 → 0.9.0-rc.180

package/dist/repository/task-log-migration.d.ts

@@ -0,0 +1,74 @@
+export type TaskLogMigrationMode = 'dry-run' | 'apply' | 'verify';
+export declare const TASK_LOG_MIGRATION_TERMINAL_STATUSES: readonly ["success", "failed", "completed"];
+export declare const TASK_LOG_MIGRATION_MIN_FREE_SPACE_BYTES: number;
+export declare const TASK_LOG_MIGRATION_EVENT_ROW_BYTES = 256;
+export type TaskLogVerificationIssueKind = 'malformed-blob' | 'mixed-source' | 'seq-gap' | 'duplicate-seq' | 'orphan-event' | 'count-mismatch' | 'source-invariant' | 'invalid-event';
+export type TaskLogMigrationFailureKind = 'malformed' | 'mixed-source' | 'metadata' | 'invalid-source';
+export interface TaskLogMigrationOptions {
+    mode: TaskLogMigrationMode;
+    dbPath?: string;
+    batchTasks?: number;
+    backupPath?: string;
+}
+export interface TaskLogMigrationFailure {
+    taskId: string;
+    reason: string;
+    kind?: TaskLogMigrationFailureKind;
+}
+export interface TaskLogVerificationIssue {
+    taskId: string | null;
+    kind: TaskLogVerificationIssueKind;
+    reason: string;
+    expected?: number;
+    actual?: number;
+    seq?: number;
+}
+export interface TaskLogVerificationReport {
+    checkedTasks: number;
+    eventSourceTasks: number;
+    blobSourceTasks: number;
+    eventCount: number;
+    orphanEventCount: number;
+    failedTasks: number;
+    issues: TaskLogVerificationIssue[];
+}
+export interface TaskLogMigrationReport {
+    mode: TaskLogMigrationMode;
+    ok: boolean;
+    dbPath: string;
+    backupPath?: string;
+    backupMethod?: 'sqlite-online-backup';
+    blockedReason?: string;
+    activeTaskCount: number;
+    taskCount: number;
+    candidateTaskCount: number;
+    eligibleTaskCount: number;
+    statusCounts: Record<string, number>;
+    deferredTaskCount: number;
+    deferredStatusCounts: Record<string, number>;
+    entryCount: number;
+    sourceBytes: number;
+    estimatedFreeSpaceBytes: number;
+    requiredFreeSpaceBytes: number;
+    availableFreeSpaceBytes: number;
+    minimumFreeSpaceReserveBytes: number;
+    freeSpaceGatePassed: boolean;
+    migratedTasks: number;
+    migratedEntries: number;
+    skippedTasks: number;
+    failedTasks: number;
+    malformedRows: TaskLogMigrationFailure[];
+    failures: TaskLogMigrationFailure[];
+    logicalSourceBytesRemoved: number;
+    warnings: string[];
+    remainingTaskCount: number;
+    verification?: TaskLogVerificationReport;
+}
+export declare function resolveTaskLogMigrationDbPath(dbPath?: string): string;
+export declare function hasSufficientTaskLogMigrationFreeSpace(availableFreeSpaceBytes: number, estimatedFreeSpaceBytes: number): boolean;
+export interface TaskLogWalCheckpointConnection {
+    pragma(pragma: string): unknown;
+}
+export declare function tryCheckpointTaskLogWal(db: TaskLogWalCheckpointConnection): string | undefined;
+export declare function runTaskLogMigration(options: TaskLogMigrationOptions): Promise<TaskLogMigrationReport>;
+export declare function taskLogBackupName(backupPath: string): string;

package/dist/repository/task-log.repository.d.ts

@@ -0,0 +1,47 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export type TaskLogStorage = 'blob' | 'events';
+export interface TaskLogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+}
+export type RawTaskLogEntry = TaskLogEntry;
+export type TaskLogRawEntry = TaskLogEntry;
+export interface TaskLogState {
+    taskId: string;
+    source: TaskLogStorage;
+    revision: number;
+    lastSeq: number;
+}
+export type TaskLogReadEntry = TaskLogEntry & {
+    readonly seq: number;
+};
+export interface TaskLogReadResult extends TaskLogState {
+    entries: TaskLogReadEntry[];
+}
+export interface TaskLogRepositoryContract {
+    appendLog(taskId: string, entry: TaskLogEntry): TaskLogState;
+    appendLogs(taskId: string, entries: readonly TaskLogEntry[]): TaskLogState;
+    readLogs(taskId: string): TaskLogReadResult | undefined;
+    readLogsTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    getLogState(taskId: string): TaskLogState | undefined;
+}
+export declare class TaskLogRepository extends BaseSqliteRepository implements TaskLogRepositoryContract {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private findStateRow;
+    private findStateRowInTransaction;
+    private requireStateRowInTransaction;
+    appendLog(taskId: string, entry: TaskLogEntry): TaskLogState;
+    appendLogs(taskId: string, entries: readonly TaskLogEntry[]): TaskLogState;
+    getLogState(taskId: string): TaskLogState | undefined;
+    readLogs(taskId: string): TaskLogReadResult | undefined;
+    readLogsTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    readTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    private readLogsInternal;
+}

package/dist/repository/task-status.d.ts

@@ -0,0 +1,21 @@
+export type TaskStatus = 'pending' | 'running' | 'paused' | 'success' | 'failed' | 'stopped';
+export declare const TASK_TERMINAL_STATUSES: readonly ["success", "failed", "stopped"];
+export declare const TASK_TERMINAL_STORED_STATUSES: readonly ["success", "completed", "done", "failed", "error", "stopped", "runner_lost"];
+export declare function storedTaskStatusesFor(statuses: readonly string[]): string[];
+export type TaskTerminalStatus = (typeof TASK_TERMINAL_STATUSES)[number];
+export type TaskTerminalReason = 'user_stop' | 'runner_lost' | 'launch_failed';
+export declare const LEGACY_TASK_TERMINAL_ERROR_PATTERNS: {
+    readonly stopped: RegExp;
+    readonly runnerLost: RegExp;
+};
+export interface TaskStatusInput {
+    status: string;
+    error?: string | null;
+    metadata?: string | null;
+}
+export declare function readTaskTerminalReason(row: TaskStatusInput): TaskTerminalReason | undefined;
+export declare function normalizeTaskStatus(row: TaskStatusInput): TaskStatus;
+export declare function normalizeTaskRow<T extends TaskStatusInput>(row: T): Omit<T, 'status'> & {
+    status: TaskStatus;
+};
+export declare function isTaskRetryableByDefault(row: TaskStatusInput): boolean;

package/dist/repository/task.repository.d.ts

@@ -1,21 +1,127 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { DrizzleDb } from './db.js';
+import { RepositoryError } from './errors.js';
 import { tasks } from '../schema/index.js';
-export type TaskRow = typeof tasks.$inferSelect;
+import { type WorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+import { type ProcessControlOptions } from '../process/process-control.js';
+import type { TaskLogEntry, TaskLogReadResult, TaskLogState } from './task-log.repository.js';
+import { type TaskStatus, type TaskTerminalReason } from './task-status.js';
+import { type StopTaskOptions, type StopTaskGenerationForInstructionOptions, type StopTaskResult } from '../lifecycle/task-stop.js';
+export { TASK_HEARTBEAT_HARD_STALE_MS, TASK_HEARTBEAT_INTERVAL_MS, TASK_HEARTBEAT_STALE_MS, resolveTaskHeartbeatHardStaleMs, resolveTaskHeartbeatIntervalMs, resolveTaskHeartbeatStaleMs, } from '../lifecycle/task-heartbeat.js';
+type RawTaskRow = Omit<typeof tasks.$inferSelect, 'security_key'>;
+export type TaskRow = Omit<RawTaskRow, 'status'> & {
+    status: TaskStatus;
+};
+export interface ProviderInputRecord {
+    runEpoch: number;
+    input: string;
+    keyWrapSkipped: boolean;
+    recordedAt: string;
+}
+export interface ProviderInputEpochEntry {
+    runEpoch: number;
+    available: boolean;
+    reason?: 'absent' | 'pruned';
+    keyWrapSkipped?: true;
+}
 export type NewTask = typeof tasks.$inferInsert;
-export type TaskListRow = Pick<TaskRow, 'id' | 'thread_id' | 'agent_id' | 'status' | 'parent_task_id' | 'started_at' | 'completed_at' | 'duration_ms' | 'input_tokens' | 'output_tokens' | 'cost_usd' | 'error'>;
+type TaskActorKind = NonNullable<NewTask['actor_kind']>;
+export type TaskKillStatus = 'terminated' | 'not_found' | 'failed' | 'not_running';
+export interface TaskKillResult {
+    status: TaskKillStatus;
+    killed: boolean;
+    pid?: number;
+    error?: string;
+}
+export interface TaskStopRequestResult {
+    accepted: boolean;
+    status: string | null;
+    runEpoch: number;
+    alreadyRequestedAt?: string;
+}
+export type TaskStopOrigin = 'http' | 'cli' | 'instruction' | 'workflow' | 'internal';
+export interface TaskStopRequestContext {
+    origin?: TaskStopOrigin;
+    at?: string;
+    callerPid?: number;
+    callerTaskId?: string;
+}
+export type TaskStopMethod = 'cooperative' | 'forced';
+export interface FinalizeTaskStopOptions {
+    id: string;
+    runEpoch: number;
+    completedAt?: string;
+    method: TaskStopMethod;
+    error?: string;
+    terminalReason?: TaskTerminalReason;
+    durationMs?: number | null;
+}
+export interface FinalizeTaskForHostShutdownOptions {
+    id: string;
+    expectedRunEpoch: number;
+    workspaceId?: string | null;
+    completedAt?: string;
+}
+export type FinalizeTaskForHostShutdownOutcome = 'settled' | 'not_running' | 'epoch_mismatch' | 'workspace_mismatch';
+export type TaskListRow = Pick<TaskRow, 'id' | 'thread_id' | 'agent_id' | 'status' | 'parent_task_id' | 'started_at' | 'completed_at' | 'duration_ms' | 'input_tokens' | 'output_tokens' | 'cost_usd' | 'error' | 'rating' | 'rated_at'> & {
+    terminalReason: TaskTerminalReason | null;
+};
+export type TaskActivityLogRow = Pick<TaskRow, 'id' | 'thread_id' | 'agent_id' | 'parent_task_id' | 'started_at' | 'completed_at'>;
+export type FindTasksByThreadOptions = {
+    projection: 'activity-log';
+};
+export interface WorkflowCardRow {
+    taskId: string;
+    workflowRunId?: string;
+    raw?: string;
+}
+export interface WorkflowParentTaskRow {
+    id: string;
+    agent_id: string;
+    thread_id: string | null;
+    workspace_id: string | null;
+    platform: string | null;
+    status: string;
+    error: string | null;
+    completed_at: string | null;
+    duration_ms: number | null;
+    started_at: string;
+    metadata: string | null;
+}
+export { WORKFLOW_ANCHOR_TASK_KINDS, isWorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+export type { WorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+export type WorkflowParentTaskKind = WorkflowAnchorTaskKind;
+export interface WorkflowParentTaskLookup {
+    workspaceId: string;
+    workflowRunId: string;
+    kind: WorkflowParentTaskKind;
+}
+export interface AgentProviderUsageRow {
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    totalTasks: number;
+    unavailableTaskCount: number;
+}
 export interface AgentUsageRow {
     agentId: string;
     workspaceId: string | null;
     totalTasks: number;
+    unavailableTaskCount?: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
     costUsd: number;
     totalTokens: number;
+    providers: AgentProviderUsageRow[];
 }
 export interface TrendRow {
     date: string;
     agentId: string;
+    unavailableTaskCount?: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
@@ -25,6 +131,7 @@ export interface TrendRow {
 export interface ProviderUsageRow {
     provider: string;
     totalTasks: number;
+    unavailableTaskCount?: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
@@ -37,6 +144,7 @@ export interface ModelUsageRow {
     model: string;
     provider: string;
     totalTasks: number;
+    unavailableTaskCount?: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
@@ -52,20 +160,84 @@ export interface ReportTaskRow {
     status: string;
     error: string | null;
     exitCode: number | null;
+    terminalReason: TaskTerminalReason | null;
+}
+export interface DelegationEdge {
+    callerAgentId: string | null;
+    agentId: string;
+    taskCount: number;
+    totalTokens: number;
+    outputTokens: number;
+}
+export interface DelegationMatrixResult {
+    edges: DelegationEdge[];
+    truncated: boolean;
+}
+export type TaskEvidenceRow = Pick<TaskRow, 'id' | 'agent_id' | 'status' | 'prompt' | 'started_at' | 'completed_at' | 'thread_id'> & {
+    terminalReason: TaskTerminalReason | null;
+};
+export interface ThreadChainTurn {
+    id: string;
+    agentId: string;
+    status: string;
+    prompt: string;
+    startedAt: string;
+    completedAt: string | null;
 }
+export interface ThreadChain {
+    threadId: string;
+    targetAgentTurnCount: number;
+    turns: ThreadChainTurn[];
+}
+export declare const CANONICAL_USER_STOP_ERROR = "Stopped by user";
+export declare const HOST_SHUTDOWN_TERMINAL_ERROR = "Stopped by app shutdown";
+type TaskUsageColumns = Pick<TaskRow, 'input_tokens' | 'output_tokens' | 'cached_input_tokens' | 'cost_usd'>;
+export declare function mergeTerminalReason(metadataJson: string | null | undefined, reason: TaskTerminalReason): string;
+export declare function hasRecordedUsage(task: TaskUsageColumns): boolean;
 export declare const PID_NULL_REAP_GRACE_MS: number;
+export declare const PENDING_ADOPT_GRACE_MS: number;
+export declare const DEFAULT_TASK_REAPER_TICK_INTERVAL_MS: number;
+export interface ReapOrphanedTasksOptions {
+    tickIntervalMs?: number;
+}
 export declare class TaskRepository extends BaseSqliteRepository {
     private readonly dbPath?;
+    private readonly clock;
+    private readonly taskLogRepository;
+    private readonly processControl;
+    private lastReaperTickAt?;
+    private orphanReapInFlight?;
     private readonly pidNullObservedSince;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
+        clock?: () => number;
+        processControl?: ProcessControlOptions;
     });
     resolveDbPath(): string;
     private openHandle;
+    heartbeatTask(opts: {
+        id: string;
+        runEpoch: number;
+    }): boolean;
+    requestTaskStop(opts: {
+        id: string;
+        requestedAt: string;
+        origin?: TaskStopOrigin;
+        callerPid?: number;
+        callerTaskId?: string;
+    }): TaskStopRequestResult;
+    private requestTaskStopForInstruction;
+    finalizeTaskStop(opts: FinalizeTaskStopOptions): boolean;
+    finalizeTaskForHostShutdown(opts: FinalizeTaskForHostShutdownOptions): FinalizeTaskForHostShutdownOutcome;
+    stopTask(id: string, options?: StopTaskOptions): Promise<StopTaskResult>;
+    stopTaskGenerationForInstruction(options: StopTaskGenerationForInstructionOptions): Promise<StopTaskResult>;
     startTask(opts: {
         id: string;
         agentId: string;
+        actorKind?: TaskActorKind | null;
+        actorId?: string | null;
+        userId?: string | null;
         prompt: string;
         mode: string;
         status: string;
@@ -77,13 +249,38 @@ export declare class TaskRepository extends BaseSqliteRepository {
         command?: string | null;
         metadata?: string | null;
         workspaceId?: string | null;
+        cwd?: string | null;
+        projectId?: string | null;
         platform?: string | null;
         crewxVersion?: string | null;
         threadId?: string | null;
         model?: string | null;
         renderedPrompt?: string | null;
+        securityKey?: string | null;
         codingAgentCommand?: string | null;
     }): void;
+    recordTaskPid(opts: {
+        id: string;
+        runEpoch: number;
+        pid: number;
+    }): boolean;
+    updateTaskOwnership(opts: {
+        id: string;
+        runEpoch: number;
+        ownership: 'runner' | 'caller';
+        providerPid?: number | null;
+        runtime?: {
+            model?: string | null;
+            renderedPrompt?: string | null;
+            securityKey?: string | null;
+            codingAgentCommand?: string | null;
+            metadata?: Record<string, unknown>;
+        };
+    }): boolean;
+    adoptPendingTask(id: string): boolean;
+    failPendingTask(id: string, error: string, completedAt?: string): boolean;
+    stopPendingTask(id: string, error?: string, completedAt?: string, stopRequest?: TaskStopRequestContext): boolean;
+    listTasksByProjectId(projectId: string): TaskRow[];
     finishTask(opts: {
         id: string;
         status: string;
@@ -98,20 +295,49 @@ export declare class TaskRepository extends BaseSqliteRepository {
         costUsd?: number;
         model?: string | null;
         runEpoch?: number | null;
+        partialResultRecovered?: boolean;
+    }): void;
+    updateTaskLifecycle(opts: {
+        id: string;
+        status: TaskStatus;
+        error: string | null;
+        completedAt: string | null;
+        durationMs: number | null;
+        workspaceId: string;
+        terminalReason?: TaskTerminalReason;
     }): void;
     appendLog(taskId: string, entry: {
         timestamp: string;
         level: string;
         message: string;
     }): void;
+    appendLogs(taskId: string, entries: readonly TaskLogEntry[]): void;
+    readLogs(taskId: string): TaskLogReadResult | undefined;
+    readLogsTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    getLogState(taskId: string): TaskLogState | undefined;
     getRunningTasks(): TaskRow[];
+    getActiveTasks(): TaskRow[];
     getAllTasks(): TaskRow[];
+    readTaskSecurityKey(id: string): string | null;
+    recordProviderInput(opts: {
+        id: string;
+        runEpoch: number;
+        input: string;
+        keyWrapSkipped: boolean;
+        interceptedRequest?: boolean;
+        recordedAt?: string;
+    }): boolean;
+    listProviderInputEpochs(id: string, opts?: {
+        archivedRunEpochs?: ReadonlySet<number>;
+    }): ProviderInputEpochEntry[];
+    readProviderInput(id: string, runEpoch: number): ProviderInputRecord | undefined;
     getTask(id: string): TaskRow | undefined;
-    killTask(id: string): {
-        killed: boolean;
-        pid?: number;
-    };
-    reapOrphanedTasks(): number;
+    killTask(id: string): Promise<TaskKillResult>;
+    reapOrphanedTasks(options?: ReapOrphanedTasksOptions): Promise<number>;
+    private runOrphanReaperPass;
+    private judgeRecordedTargets;
+    private terminateRecordedProcesses;
+    reapRunningWorkflowTasks(graceMs?: number): number;
     findTaskStatus(taskId: string, workspaceId?: string): TaskRow | undefined;
     findChildTasks(parentTaskId: string, workspaceId?: string): TaskRow[];
     getWorkspaceUsageSummary(workspaceId?: string): Array<{
@@ -126,7 +352,14 @@ export declare class TaskRepository extends BaseSqliteRepository {
         outputTokens: number;
         costUsd: number;
     };
+    findTasksByThread(threadId: string, workspaceId: string | undefined, options: FindTasksByThreadOptions): TaskActivityLogRow[];
     findTasksByThread(threadId: string, workspaceId?: string): TaskRow[];
+    private parseWorkflowCardMetadata;
+    private extractThreadIdFromCommand;
+    findRunningWorkflowParentTasks(): WorkflowParentTaskRow[];
+    findWorkflowParentTasksByWorkspace(workspaceId: string): WorkflowParentTaskRow[];
+    findWorkflowParentTask(opts: WorkflowParentTaskLookup): WorkflowParentTaskRow | undefined;
+    batchFetchWorkflowCards(threadIds: string[], workspaceId?: string): Map<string, WorkflowCardRow>;
     findAllTasks(params: {
         workspaceId?: string;
         agentId?: string;
@@ -147,9 +380,86 @@ export declare class TaskRepository extends BaseSqliteRepository {
     getAgentUsage(from: string, to: string, workspace?: string): AgentUsageRow[];
     getAgentUsageTrendRaw(from: string, to: string, workspace?: string): TrendRow[];
     findTaskForStop(taskId: string, workspaceId: string): TaskRow | undefined;
-    markTaskFailed(taskId: string, error: string, workspaceId?: string): void;
+    findLatestTaskByMetadata(opts: {
+        agentId: string;
+        workspaceId: string;
+        metaKey: string;
+        metaValue: string;
+    }): {
+        id: string;
+        thread_id: string | null;
+        status: string;
+        result: string | null;
+        error: string | null;
+        started_at: string;
+        completed_at: string | null;
+        metadata: string | null;
+    } | null;
+    markTaskFailed(taskId: string, error: string, workspaceId?: string, status?: TaskStatus, terminalReason?: TaskTerminalReason): void;
     findTasksByPromptHint(hint: string, workspaceId?: string): TaskRow[];
     getProviderUsage(from: string, to: string, workspace?: string): ProviderUsageRow[];
     getModelUsage(from: string, to: string, workspace?: string): ModelUsageRow[];
     getTasksForReport(from: string, to: string, workspace?: string): ReportTaskRow[];
+    getDelegationMatrix(from: string, to: string, workspace?: string): DelegationMatrixResult;
+    findTaskEvidence(params: {
+        workspaceId?: string;
+        agents?: string[];
+        statuses?: string[];
+        from?: string;
+        to?: string;
+        limit?: number;
+        order?: 'ASC' | 'DESC';
+    }): TaskEvidenceRow[];
+    findThreadChains(params: {
+        targetAgentId: string;
+        workspaceId?: string;
+        from?: string;
+        to?: string;
+        maxThreads?: number;
+        maxTurnsPerThread?: number;
+    }): ThreadChain[];
+}
+export declare const TASK_RATINGS: readonly ["up", "down"];
+export type TaskRating = (typeof TASK_RATINGS)[number];
+export declare const RATED_TASK_EXCERPT_MAX_CHARS = 1000;
+export declare const RATED_TASK_LIST_MAX_LIMIT = 200;
+export type TaskRatingErrorCode = 'TASK_NOT_FOUND' | 'TASK_RATING_NOT_TERMINAL';
+export declare class TaskRatingError extends RepositoryError {
+    readonly stableCode: TaskRatingErrorCode;
+    readonly taskId: string;
+    constructor(stableCode: TaskRatingErrorCode, taskId: string);
+}
+export interface SetTaskRatingInput {
+    workspaceId: string;
+    taskId: string;
+    rating: TaskRating | null;
+    now?: string;
+}
+export interface SetTaskRatingResult {
+    taskId: string;
+    rating: TaskRating | null;
+    ratedAt: string | null;
+    changed: boolean;
+}
+export declare function setTaskRating(db: DrizzleDb, input: SetTaskRatingInput): SetTaskRatingResult;
+export interface ListRatedTasksInput {
+    workspaceId: string;
+    agentId?: string;
+    sinceIso?: string;
+    limit: number;
+}
+export interface RatedTaskRow {
+    taskId: string;
+    agentId: string;
+    threadId: string | null;
+    status: TaskStatus;
+    rating: TaskRating;
+    ratedAt: string;
+    promptExcerpt: string | null;
+    resultExcerpt: string | null;
 }
+export declare function buildRatedTasksQuery(input: ListRatedTasksInput): import("drizzle-orm").SQL<unknown>;
+export declare function listRatedTasks(db: DrizzleDb, input: ListRatedTasksInput): RatedTaskRow[];
+export type CountRatedTasksInput = Omit<ListRatedTasksInput, 'limit'>;
+export declare function buildRatedTasksCountQuery(input: CountRatedTasksInput): import("drizzle-orm").SQL<unknown>;
+export declare function countRatedTasks(db: DrizzleDb, input: CountRatedTasksInput): number;