@crewx/sdk 0.9.0-rc.22 → 0.9.0-rc.221

package/dist/repository/logs-db.d.ts

@@ -0,0 +1,12 @@
+type SqliteDatabase = import('better-sqlite3').Database;
+export declare const LOGS_DB_FILE_NAME = "logs.db";
+export declare const LOGS_DB_SCHEMA_VERSION = 1;
+export declare function resolveCrewxLogsDbPath(crewxDbPath?: string): string;
+export declare function hashRequestLogBody(body: string): string;
+export interface LogsDbHandle {
+    readonly path: string;
+    readonly sqlite: SqliteDatabase;
+    close(): void;
+}
+export declare function openLogsDb(crewxDbPath?: string): LogsDbHandle;
+export {};

package/dist/repository/notification.repository.d.ts

@@ -0,0 +1,58 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { notifications, notification_reads } from '../schema/index.js';
+export declare const DEFAULT_NOTIFICATION_CAP = 500;
+export type NotificationRow = typeof notifications.$inferSelect;
+export type NewNotification = typeof notifications.$inferInsert;
+export type NotificationReadRow = typeof notification_reads.$inferSelect;
+export type NotificationLevel = 'info' | 'warning' | 'critical';
+export type NotificationSource = 'agent' | 'system';
+export interface CreateNotificationInput {
+    workspaceId: string;
+    agentId?: string | null;
+    taskId?: string | null;
+    threadId?: string | null;
+    source?: NotificationSource;
+    level?: NotificationLevel;
+    title: string;
+    body?: string | null;
+    targetUserId?: string | null;
+    metadata?: string | null;
+}
+export interface NotificationListItem extends NotificationRow {
+    read: boolean;
+    read_at: string | null;
+}
+export interface ListNotificationsParams {
+    workspaceId: string;
+    userId: string;
+    limit?: number;
+}
+export interface UserScope {
+    workspaceId: string;
+    userId: string;
+}
+export interface MarkReadParams {
+    notificationId: string;
+    workspaceId: string;
+    userId: string;
+}
+export declare const DEFAULT_LIST_LIMIT = 50;
+export declare class NotificationRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    private readonly cap;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+        cap?: number;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    create(input: CreateNotificationInput): {
+        id: string;
+    };
+    private enforceCap;
+    list(params: ListNotificationsParams): NotificationListItem[];
+    unreadCount(params: UserScope): number;
+    markRead(params: MarkReadParams): boolean;
+    markAllRead(params: UserScope): number;
+}

package/dist/repository/project.repository.d.ts

@@ -0,0 +1,90 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { Project as ProjectLedgerRow, ProjectCriterion as ProjectCriterionRow, ProjectEvent as ProjectEventRow } from '../schema/index.js';
+export type ProjectScene = 'planning' | 'plan_review' | 'running' | 'human_wait' | 'limit_wait' | 'failed_stop' | 'analyzing_feedback' | 'replanned' | 'awaiting_review' | 'accepted';
+export type CriterionVerifyStatus = 'pending' | 'verifying' | 'passed' | 'failed';
+export type ProjectActorType = 'user' | 'project_manager' | 'system';
+export type ProjectEventType = 'created' | 'plan_proposed' | 'plan_approved' | 'decision_requested' | 'decision_answered' | 'replanned' | 'stage_advanced' | 'criterion_verified' | 'scene_changed' | 'result_submitted' | 'accepted';
+export type ProjectEvidenceKind = 'task' | 'wi' | 'url';
+export interface ProjectStage {
+    key: string;
+    labelOverride: string | null;
+}
+export declare const DEFAULT_PROJECT_STAGE_KEYS: readonly ["outcome_plan", "contract_check", "feature_link", "use_verify", "result_review"];
+export declare const DEFAULT_PROJECT_STAGES: readonly ProjectStage[];
+export interface ProjectEvidence {
+    kind: ProjectEvidenceKind;
+    ref: string;
+    label?: string;
+}
+export interface ProjectActorInput {
+    actorType?: ProjectActorType;
+    actorId?: string | null;
+}
+export interface CreateProjectInput {
+    workspaceId: string;
+    name: string;
+    outcome: string;
+    dueDate?: string | null;
+    stages?: readonly ProjectStage[];
+    criteria: readonly string[];
+}
+export interface ListProjectsOptions {
+    includeArchived?: boolean;
+}
+export interface ListProjectEventsOptions {
+    afterSeq?: number;
+    limit?: number;
+}
+export interface AppendProjectEventInput extends ProjectActorInput {
+    projectId: string;
+    type: ProjectEventType;
+    title: string;
+    summary?: string | null;
+    payload?: Record<string, unknown>;
+}
+export interface SetCriterionVerifyInput extends ProjectActorInput {
+    projectId?: string;
+    criterionId: string;
+    verifyStatus?: CriterionVerifyStatus;
+    status?: CriterionVerifyStatus;
+}
+export interface SetCriterionEvidenceInput extends ProjectActorInput {
+    projectId?: string;
+    criterionId: string;
+    evidence: readonly ProjectEvidence[];
+}
+export interface AcceptProjectInput extends ProjectActorInput {
+    remainingRisks: unknown;
+    nextPlan: unknown;
+    lessons: unknown;
+    evidenceRefs: unknown;
+}
+export interface ProjectDetail extends ProjectLedgerRow {
+    stages: ProjectStage[];
+    criteria: ProjectCriterionRow[];
+}
+export declare class ProjectRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private getDetailFromHandle;
+    private getDetailOrThrow;
+    createProject(input: CreateProjectInput): ProjectDetail;
+    getProject(id: string): ProjectDetail | undefined;
+    listProjectsByWorkspace(workspaceId: string, options?: ListProjectsOptions): ProjectDetail[];
+    archiveProject(id: string): ProjectDetail;
+    setScene(id: string, scene: ProjectScene, actor?: ProjectActorInput): ProjectDetail;
+    setStageIndex(id: string, index: number, actor?: ProjectActorInput): ProjectDetail;
+    setCriterionVerify(input: SetCriterionVerifyInput): ProjectCriterionRow;
+    setCriterionVerify(projectId: string, criterionId: string, status: CriterionVerifyStatus, actor?: ProjectActorInput): ProjectCriterionRow;
+    setCriterionEvidence(input: SetCriterionEvidenceInput): ProjectCriterionRow;
+    setCriterionEvidence(projectId: string, criterionId: string, evidence: readonly ProjectEvidence[], actor?: ProjectActorInput): ProjectCriterionRow;
+    appendEvent(input: AppendProjectEventInput): ProjectEventRow;
+    appendEvent(projectId: string, input: Omit<AppendProjectEventInput, 'projectId'>): ProjectEventRow;
+    listEvents(projectId: string, options?: ListProjectEventsOptions): ProjectEventRow[];
+    acceptProject(id: string, input: AcceptProjectInput): ProjectDetail;
+}

package/dist/repository/public-task-answer.d.ts

@@ -0,0 +1,24 @@
+import type { TaskStatus } from './task-status.js';
+export declare const UNREAD_PREVIEW_MAX_LENGTH = 120;
+export interface PublicTaskAnswerInput {
+    result: string | null;
+    status: string;
+    error: string | null;
+    metadata: string | null;
+}
+export interface UnreadReplyCandidate {
+    id: string;
+    threadId: string;
+    completedAt: string;
+    status: TaskStatus;
+    result: string | null;
+    error: string | null;
+    metadata: string | null;
+}
+export interface UnreadReplySummary {
+    unreadCount: number;
+    unreadPreview: string | null;
+}
+export declare function publicTaskAnswerContent(task: PublicTaskAnswerInput): string;
+export declare function toPreviewPlainText(content: string, maxLength?: number): string;
+export declare function summarizeUnreadReplies(candidates: readonly UnreadReplyCandidate[]): UnreadReplySummary;

package/dist/repository/request-log-mover.d.ts

@@ -0,0 +1,70 @@
+export declare const REQUEST_LOG_MOVE_DEFAULT_BATCH_ROWS = 250;
+export declare const REQUEST_LOG_MOVE_DEFAULT_BATCH_BYTES: number;
+export declare const REQUEST_LOG_MOVE_CHECKPOINT_WAL_BYTES: number;
+export declare const REQUEST_LOG_MOVE_CHECKPOINT_MIN_INTERVAL_MS = 5000;
+export interface MoveRequestLogsProgress {
+    batches: number;
+    scannedRows: number;
+    movedRows: number;
+    bodiesAdded: number;
+    lastRowid: number;
+    elapsedMs: number;
+    deleteTxMs: number;
+    walBytes: number;
+}
+export interface MoveRequestLogsTestHooks {
+    afterRead?: (rows: ReadonlyArray<{
+        rowid: number;
+        id: string;
+    }>) => void;
+    afterLogsCommit?: (rows: ReadonlyArray<{
+        rowid: number;
+        id: string;
+    }>) => void;
+}
+export interface MoveRequestLogsOptions {
+    crewxDbPath?: string;
+    batchRows?: number;
+    batchBytes?: number;
+    maxBatches?: number;
+    maxMs?: number;
+    dryRun?: boolean;
+    checkpointWalBytes?: number;
+    checkpointMinIntervalMs?: number;
+    onProgress?: (progress: MoveRequestLogsProgress) => void;
+    testHooks?: MoveRequestLogsTestHooks;
+}
+export interface MoveRequestLogsResult {
+    crewxDbPath: string;
+    logsDbPath: string;
+    dryRun: boolean;
+    movedRows: number;
+    remainingRows: number;
+    bodiesAdded: number;
+    batches: number;
+    maxDeleteTxMs: number;
+    deleteTxMs: number[];
+    maxWalBytes: number;
+    checkpoints: number;
+    elapsedMs: number;
+    sliceLimitReached: boolean;
+    scan?: {
+        rows: number;
+        bodies: number;
+        bodyBytes: number;
+        distinctBodies: number;
+        distinctBodyBytes: number;
+    };
+}
+export declare function moveRequestLogsToLogsDb(opts?: MoveRequestLogsOptions): MoveRequestLogsResult;
+export interface RequestLogsMoveStatus {
+    crewxDbPath: string;
+    logsDbPath: string;
+    crewxRows: number;
+    crewxFreelistPages: number;
+    logsRows: number | null;
+    logsBodies: number | null;
+    logsFileBytes: number;
+    logsWalBytes: number;
+}
+export declare function inspectRequestLogsMove(crewxDbPath?: string): RequestLogsMoveStatus;

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

@@ -1,5 +1,5 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
-import { request_logs } from '../schema/index.js';
+import type { request_logs } from '../schema/index.js';
 export type RequestLogRow = typeof request_logs.$inferSelect;
 export type NewRequestLog = typeof request_logs.$inferInsert;
 export interface RequestLogEntry {
@@ -16,16 +16,20 @@ export interface RequestLogEntry {
     userId?: string;
     projectId?: string;
     partitionKey?: string;
+    timestamp?: string;
     metadata?: string;
 }
 export declare class RequestLogRepository extends BaseSqliteRepository {
     private readonly dbPath?;
+    private writer?;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
     });
     resolveDbPath(): string;
-    private openHandle;
+    resolveLogsDbPath(): string;
+    private ensureWriter;
     bulkInsert(entries: RequestLogEntry[]): void;
-    findRecent(limit?: number): RequestLogRow[];
+    private prepareRow;
+    close(): void;
 }

package/dist/repository/run-columns.d.ts

@@ -0,0 +1,10 @@
+export declare const RUN_COLUMNS_BACKFILL = "tasks_run_columns";
+export declare const WORKFLOW_RUN_INDEX = "idx_tasks_workflow_run_id";
+export declare const SCHEDULE_TASKS_INDEX = "idx_tasks_ws_schedule_started";
+export declare const HUMAN_TASKS_INDEX = "idx_tasks_ws_human_started";
+export declare const RUN_COLUMN_INDEXES: ReadonlyArray<{
+    name: string;
+    sql: string;
+}>;
+export declare const SCHEDULED_TRIGGERS: readonly ["cron", "cron_manual"];
+export declare function readScheduleIdFromMetadata(metadata: string | null | undefined): string | null;

package/dist/repository/run-history.repository.d.ts

@@ -0,0 +1,112 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { ScheduleRunMode } from './schedule-run.repository.js';
+import { type TaskStatus } from './task-status.js';
+export type RunHistoryOrigin = 'all' | 'mine' | 'delegated' | 'scheduled' | 'workflow';
+export type RunHistoryKind = 'task' | 'workflow' | 'schedule_run';
+export type RunHistoryClass = 'mine' | 'delegated' | 'scheduled' | 'workflow' | 'system' | 'unknown';
+export type RunHistoryTerminalReason = 'user_stop' | 'runner_lost' | 'launch_failed';
+export interface RunHistoryQuery {
+    workspaceId: string;
+    origin?: RunHistoryOrigin;
+    scheduleId?: string;
+    includeFrequentSuccess?: boolean;
+    agents?: readonly string[];
+    statuses?: readonly TaskStatus[];
+    q?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface RunHistoryRow {
+    kind: RunHistoryKind;
+    id: string;
+    origin: RunHistoryClass;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    status: TaskStatus;
+    terminalReason: RunHistoryTerminalReason | null;
+    agentId: string | null;
+    mode: ScheduleRunMode | null;
+    taskId: string | null;
+    scheduleId: string | null;
+    scheduleName: string | null;
+    builtinId: string | null;
+    workflowRunId: string | null;
+    highFrequency: boolean;
+    errorCode: string | null;
+    preview: string | null;
+}
+export interface RunHistoryPage {
+    rows: RunHistoryRow[];
+    total: number;
+}
+export interface ScheduleRunSummaryLastRun {
+    kind: 'task' | 'schedule_run';
+    id: string;
+    taskId: string | null;
+    status: TaskStatus;
+    startedAt: string;
+    finishedAt: string | null;
+}
+export interface ScheduleRunSummary {
+    lastRun: ScheduleRunSummaryLastRun | null;
+    succeededToday: number;
+    failedLast24h: number;
+    checkedAt: string;
+}
+export interface ScheduleRunSummaryInput {
+    workspaceId: string;
+    scheduleIds: readonly string[];
+    timezoneBySchedule: Readonly<Record<string, string | undefined>>;
+    now: Date;
+}
+export interface FailedScheduleRunsSinceInput {
+    workspaceId: string;
+    since: Date;
+}
+export interface RunTaskIdsInput {
+    workspaceId: string;
+    taskIds: readonly string[];
+}
+export interface RunTaskListItemRow {
+    id: string;
+    model: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cost_usd: number | null;
+    thread_id: string | null;
+    metadata: string | null;
+    coding_agent_command: string | null;
+    caller_agent_id: string | null;
+    parent_agent_id: string | null;
+}
+export interface RunScheduleRunByTask {
+    taskId: string;
+    scheduleName: string | null;
+    builtinId: string | null;
+}
+export interface RunColumnBackfillInput {
+    batchSize?: number;
+}
+export interface RunColumnBackfillResult {
+    scanned: number;
+    updated: number;
+    done: boolean;
+    indexesBuilt: string[];
+}
+export declare const RUN_HISTORY_PREVIEW_RAW_CHARS = 1000;
+export declare class RunHistoryRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private withReadable;
+    listRunHistory(query: RunHistoryQuery): RunHistoryPage;
+    getScheduleRunSummaries(input: ScheduleRunSummaryInput): Record<string, ScheduleRunSummary>;
+    countFailedScheduleRunsSince(input: FailedScheduleRunsSinceInput): number;
+    listTaskListItems(input: RunTaskIdsInput): RunTaskListItemRow[];
+    listScheduleRunsByTaskIds(input: RunTaskIdsInput): RunScheduleRunByTask[];
+    backfillRunColumns(input?: RunColumnBackfillInput): RunColumnBackfillResult;
+}

package/dist/repository/schedule-run.repository.d.ts

@@ -0,0 +1,103 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export type ScheduleRunMode = 'command' | 'agent' | 'app';
+export type ScheduleRunStatus = 'running' | 'success' | 'failed' | 'lost';
+export interface ScheduleRun {
+    id: string;
+    scheduleId: string;
+    workspaceId: string;
+    mode: ScheduleRunMode;
+    trigger: string;
+    occurrenceKey: string | null;
+    taskId: string | null;
+    appId: string | null;
+    scheduleName: string | null;
+    builtinId: string | null;
+    command: string | null;
+    highFrequency: boolean;
+    status: ScheduleRunStatus;
+    errorCode: string | null;
+    exitCode: number | null;
+    signal: string | null;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    pid: number | null;
+    hostPid: number | null;
+    outputTail: string | null;
+    outputBytes: number | null;
+    outputTruncated: boolean;
+}
+export interface NewScheduleRun {
+    id: string;
+    scheduleId: string;
+    workspaceId: string;
+    mode: ScheduleRunMode;
+    trigger: string;
+    occurrenceKey?: string | null;
+    taskId?: string | null;
+    appId?: string | null;
+    scheduleName?: string | null;
+    builtinId?: string | null;
+    command?: string | null;
+    highFrequency: boolean;
+    status: ScheduleRunStatus;
+    errorCode?: string | null;
+    startedAt: string;
+    finishedAt?: string | null;
+    durationMs?: number | null;
+    pid?: number | null;
+    hostPid?: number | null;
+}
+export interface ScheduleRunFinish {
+    status: 'success' | 'failed' | 'lost';
+    errorCode?: string | null;
+    exitCode?: number | null;
+    signal?: string | null;
+    finishedAt: string;
+    durationMs: number;
+    outputTail?: string | null;
+    outputBytes?: number | null;
+    outputTruncated?: boolean;
+}
+export interface ScheduleRunListOptions {
+    scheduleId?: string;
+    mode?: ScheduleRunMode;
+    limit?: number;
+}
+export interface ScheduleRunPruneResult {
+    deleted: number;
+    tailsCleared: number;
+}
+export interface ScheduleRunRepositoryInterface {
+    insert(run: NewScheduleRun): void;
+    finish(id: string, finish: ScheduleRunFinish): boolean;
+    markLost(id: string, finish: Omit<ScheduleRunFinish, 'status'>): boolean;
+    get(id: string): ScheduleRun | undefined;
+    listByWorkspace(workspaceId: string, options?: ScheduleRunListOptions): ScheduleRun[];
+    listBySchedule(workspaceId: string, scheduleId: string, limit?: number): ScheduleRun[];
+    listRunning(workspaceId: string): ScheduleRun[];
+    prune(workspaceId: string, now: Date): ScheduleRunPruneResult;
+}
+export declare const SCHEDULE_RUN_COMMAND_MAX_BYTES: number;
+export declare const SCHEDULE_RUN_SUCCESS_RETENTION_MS: number;
+export declare const SCHEDULE_RUN_FAILURE_RETENTION_MS: number;
+export declare const SCHEDULE_RUN_SUCCESS_TAIL_KEEP = 20;
+export declare const SCHEDULE_RUN_FAILURE_TAIL_KEEP = 50;
+export declare class ScheduleRunRepository extends BaseSqliteRepository implements ScheduleRunRepositoryInterface {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openWritable;
+    private withReadable;
+    insert(run: NewScheduleRun): void;
+    finish(id: string, finish: ScheduleRunFinish): boolean;
+    markLost(id: string, finish: Omit<ScheduleRunFinish, 'status'>): boolean;
+    get(id: string): ScheduleRun | undefined;
+    listByWorkspace(workspaceId: string, options?: ScheduleRunListOptions): ScheduleRun[];
+    listBySchedule(workspaceId: string, scheduleId: string, limit?: number): ScheduleRun[];
+    listRunning(workspaceId: string): ScheduleRun[];
+    prune(workspaceId: string, now: Date): ScheduleRunPruneResult;
+}

package/dist/repository/sidebar-tab.repository.d.ts

@@ -0,0 +1,86 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { RepositoryError } from './errors.js';
+import type { SidebarGroupColor } from '../schema/index.js';
+export declare const SIDEBAR_CLOSED_TAB_LIMIT = 20;
+export declare const SIDEBAR_CLOSED_TAB_TTL_MS: number;
+export type SidebarTabErrorReason = 'NOT_FOUND' | 'INVALID_INPUT' | 'NOT_INITIALIZED';
+export declare class SidebarTabRepositoryError extends RepositoryError {
+    readonly reason: SidebarTabErrorReason;
+    constructor(reason: SidebarTabErrorReason, message?: string, cause?: unknown);
+}
+export interface SidebarGroupSnapshot {
+    id: string;
+    name: string;
+    color: SidebarGroupColor;
+    collapsed: boolean;
+    threadIds: string[];
+}
+export interface SidebarSnapshot {
+    revision: number;
+    railCollapsed: boolean;
+    pinned: string[];
+    groups: SidebarGroupSnapshot[];
+    ungrouped: string[];
+    closedCount: number;
+    closedNextExpiryAt: string | null;
+    reads: Record<string, string>;
+}
+export interface InitSidebarResult {
+    created: boolean;
+    snapshot: SidebarSnapshot;
+}
+export interface OpenSidebarTabOptions {
+    groupId?: string;
+    beforeThreadId?: string | null;
+}
+export interface MoveSidebarTabInput {
+    section: 'pinned' | 'group' | 'ungrouped';
+    groupId?: string;
+    beforeThreadId: string | null;
+}
+export interface CreateSidebarGroupInput {
+    threadId: string;
+    color: SidebarGroupColor;
+    name?: string;
+}
+export interface UpdateSidebarGroupPatch {
+    name?: string;
+    color?: SidebarGroupColor;
+    collapsed?: boolean;
+}
+export interface ReopenSidebarTabResult {
+    threadId: string | null;
+    snapshot: SidebarSnapshot;
+}
+export interface CreateSidebarGroupResult {
+    groupId: string;
+    snapshot: SidebarSnapshot;
+}
+export interface MarkThreadReadResult {
+    readThroughAt: string;
+}
+export declare class SidebarTabRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    private readonly clock;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+        clock?: () => number;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private write;
+    private command;
+    getSnapshot(workspaceId: string): SidebarSnapshot | null;
+    initIfAbsent(workspaceId: string, seedThreadIds: string[]): InitSidebarResult;
+    open(workspaceId: string, threadId: string, options?: OpenSidebarTabOptions): SidebarSnapshot;
+    close(workspaceId: string, threadId: string): SidebarSnapshot;
+    reopenLast(workspaceId: string): ReopenSidebarTabResult;
+    move(workspaceId: string, threadId: string, input: MoveSidebarTabInput): SidebarSnapshot;
+    createGroup(workspaceId: string, input: CreateSidebarGroupInput): CreateSidebarGroupResult;
+    updateGroup(workspaceId: string, groupId: string, patch: UpdateSidebarGroupPatch): SidebarSnapshot;
+    ungroup(workspaceId: string, groupId: string): SidebarSnapshot;
+    moveGroup(workspaceId: string, groupId: string, beforeGroupId: string | null): SidebarSnapshot;
+    setRailCollapsed(workspaceId: string, railCollapsed: boolean): SidebarSnapshot;
+    markRead(workspaceId: string, threadId: string, throughTaskId: string): MarkThreadReadResult;
+}

package/dist/repository/storage-metadata.repository.d.ts

@@ -0,0 +1,64 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export declare const STORAGE_METADATA_KINDS: readonly ["taskLogs", "requestLogs", "prompts", "threadsLedger", "tasksLedger"];
+export declare const STORAGE_METADATA_UNITS: readonly ["task_log_events", "request_logs", "tasks", "threads"];
+export type StorageMetadataKind = (typeof STORAGE_METADATA_KINDS)[number];
+export type StorageMetadataUnit = (typeof STORAGE_METADATA_UNITS)[number];
+export type StorageMetadataAge = 'over6m' | 'm3to6' | 'm1to3' | 'recent1m';
+export interface StorageMetadataAggregateRow {
+    sourceKind: StorageMetadataKind;
+    age: StorageMetadataAge;
+    count: number;
+    bytes: number;
+}
+export interface StorageMetadataCutoffs {
+    cutoff6: string;
+    cutoff3: string;
+    cutoff1: string;
+}
+export interface StorageMetadataUnitReadiness {
+    cursorRowid: number;
+    endRowid: number | null;
+    complete: boolean;
+}
+export interface StorageMetadataReadiness {
+    ready: boolean;
+    units: Record<StorageMetadataUnit, StorageMetadataUnitReadiness>;
+}
+export interface StorageMetadataSnapshot {
+    readiness: StorageMetadataReadiness;
+    rows: StorageMetadataAggregateRow[];
+}
+export interface StorageMetadataBatchResult {
+    unit: StorageMetadataUnit | null;
+    rowsScanned: number;
+    rowsWritten: number;
+    cursorRowid: number;
+    complete: boolean;
+    ready: boolean;
+    elapsedMs: number;
+}
+export interface StorageMetadataVerificationMismatch {
+    sourceId: string;
+    metaBytes: number;
+    sourceBytes: number;
+}
+export declare class StorageMetadataRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private hasReadableDatabase;
+    private openWritableDatabase;
+    private readReadiness;
+    private readAggregate;
+    getReadiness(): StorageMetadataReadiness;
+    aggregate(cutoffs: StorageMetadataCutoffs): StorageMetadataAggregateRow[];
+    readSnapshot(cutoffs: StorageMetadataCutoffs): StorageMetadataSnapshot;
+    runBackfillBatch(opts?: {
+        batchSize?: number;
+        unit?: StorageMetadataUnit;
+    }): StorageMetadataBatchResult;
+    verifySample(kind: StorageMetadataKind, limit: number): StorageMetadataVerificationMismatch[];
+}