@crewx/sdk 0.9.0-rc.9 → 0.9.0-rc.91

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/request-log.repository.d.ts

@@ -16,6 +16,7 @@ export interface RequestLogEntry {
     userId?: string;
     projectId?: string;
     partitionKey?: string;
+    timestamp?: string;
     metadata?: string;
 }
 export declare class RequestLogRepository extends BaseSqliteRepository {

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,44 @@
+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 interface TaskLogReadResult extends TaskLogState {
+    entries: TaskLogEntry[];
+}
+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.repository.d.ts

@@ -1,7 +1,31 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
 import { tasks } from '../schema/index.js';
+import type { TaskLogEntry, TaskLogReadResult, TaskLogState } from './task-log.repository.js';
 export type TaskRow = typeof tasks.$inferSelect;
 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'>;
+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 interface AgentUsageRow {
     agentId: string;
     workspaceId: string | null;
@@ -32,8 +56,56 @@ export interface ProviderUsageRow {
     activeDurationMs: number;
     lastActiveAt: string | null;
 }
+export interface ModelUsageRow {
+    model: string;
+    provider: string;
+    totalTasks: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+    totalTokens: number;
+    activeDurationMs: number;
+    lastActiveAt: string | null;
+}
+export interface ReportTaskRow {
+    threadId: string | null;
+    agentId: string;
+    startedAt: string;
+    status: string;
+    error: string | null;
+    exitCode: number | 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'>;
+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 PID_NULL_REAP_GRACE_MS: number;
 export declare class TaskRepository extends BaseSqliteRepository {
     private readonly dbPath?;
+    private readonly taskLogRepository;
+    private readonly pidNullObservedSince;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
@@ -54,6 +126,7 @@ export declare class TaskRepository extends BaseSqliteRepository {
         command?: string | null;
         metadata?: string | null;
         workspaceId?: string | null;
+        projectId?: string | null;
         platform?: string | null;
         crewxVersion?: string | null;
         threadId?: string | null;
@@ -61,6 +134,7 @@ export declare class TaskRepository extends BaseSqliteRepository {
         renderedPrompt?: string | null;
         codingAgentCommand?: string | null;
     }): void;
+    listTasksByProjectId(projectId: string): TaskRow[];
     finishTask(opts: {
         id: string;
         status: string;
@@ -75,12 +149,17 @@ export declare class TaskRepository extends BaseSqliteRepository {
         costUsd?: number;
         model?: string | null;
         runEpoch?: number | null;
+        partialResultRecovered?: boolean;
     }): 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[];
     getAllTasks(): TaskRow[];
     getTask(id: string): TaskRow | undefined;
@@ -89,6 +168,7 @@ export declare class TaskRepository extends BaseSqliteRepository {
         pid?: number;
     };
     reapOrphanedTasks(): number;
+    reapRunningWorkflowTasks(graceMs?: number): number;
     findTaskStatus(taskId: string, workspaceId?: string): TaskRow | undefined;
     findChildTasks(parentTaskId: string, workspaceId?: string): TaskRow[];
     getWorkspaceUsageSummary(workspaceId?: string): Array<{
@@ -103,7 +183,12 @@ 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[];
+    batchFetchWorkflowCards(threadIds: string[], workspaceId?: string): Map<string, WorkflowCardRow>;
     findAllTasks(params: {
         workspaceId?: string;
         agentId?: string;
@@ -124,7 +209,42 @@ 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;
+    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): 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[];
 }

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

@@ -0,0 +1,193 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { RepositoryError } from './errors.js';
+import type { ThreadActorType, ThreadEvent, ThreadHighlight, ThreadHighlightKind, ThreadHighlightRun, ThreadHighlightSource } from '../schema/index.js';
+import type { ThreadPriority, ThreadState } from './thread-title.types.js';
+export interface ThreadActorInput {
+    actorType?: ThreadActorType;
+    actorId?: string | null;
+    actor?: {
+        actorType?: ThreadActorType;
+        actorId?: string | null;
+    };
+}
+export interface ThreadSnapshotMutationInput extends ThreadActorInput {
+    threadId: string;
+    workspaceId?: string | null;
+    title?: string | null;
+    priority?: ThreadPriority | null;
+    state?: ThreadState | null;
+    taskId?: string | null;
+}
+export interface ThreadSnapshot {
+    threadId: string;
+    workspaceId: string | null;
+    title: string | null;
+    priority: ThreadPriority | null;
+    state: ThreadState | null;
+    metadata: string | null;
+    titleLocked: boolean;
+    updatedAt: string;
+}
+export interface ThreadTimelineOptions {
+    beforeSeq?: number;
+    afterSeq?: number;
+    limit?: number;
+}
+export interface ThreadTimelineQuery extends ThreadTimelineOptions {
+    threadId: string;
+    workspaceId: string;
+}
+export interface ThreadTimeline {
+    items: ThreadEvent[];
+    latestSeq: number;
+    hasMoreOlder: boolean;
+}
+export interface CreateThreadHighlightInput extends ThreadActorInput {
+    threadId: string;
+    workspaceId: string;
+    source?: ThreadHighlightSource;
+    kind: ThreadHighlightKind;
+    text: string;
+    taskId?: string;
+    coversFromTaskId?: string;
+    coversToTaskId?: string;
+    fromTaskId?: string;
+    toTaskId?: string;
+    agentId?: string | null;
+    sourceTaskId?: string | null;
+    detectorVersion?: string | null;
+    contentFingerprint?: string | null;
+    idempotencyKey?: string;
+    id?: string;
+}
+export interface UpdateThreadHighlightInput extends ThreadActorInput {
+    threadId: string;
+    workspaceId: string;
+    highlightId: string;
+    expectedRevision: number;
+    text?: string;
+    kind?: ThreadHighlightKind;
+    coversFromTaskId?: string;
+    coversToTaskId?: string;
+}
+export interface DismissThreadHighlightInput extends ThreadActorInput {
+    threadId: string;
+    workspaceId: string;
+    highlightId: string;
+    expectedRevision: number;
+}
+export interface ListActiveHighlightsOptions {
+    taskId?: string;
+    coversFromTaskId?: string;
+    coversToTaskId?: string;
+}
+export interface ThreadHighlightEligibleTurn {
+    taskId: string;
+    prompt: string;
+    result: string;
+    status: string;
+    startedAt: string;
+    completedAt: string | null;
+}
+export interface CreateThreadHighlightRegenerationRunInput extends ThreadActorInput {
+    threadId: string;
+    workspaceId: string;
+    requestId: string;
+    detectorVersion: string;
+    runId?: string;
+}
+export interface CreateThreadHighlightRegenerationRunResult {
+    run: ThreadHighlightRun;
+    created: boolean;
+}
+export interface FailThreadHighlightRegenerationRunInput extends ThreadActorInput {
+    runId: string;
+    workspaceId?: string;
+    errorCode: string;
+}
+export interface ThreadHighlightRegenerationCandidate {
+    kind: ThreadHighlightKind;
+    text: string;
+    anchorTaskId: string;
+    coversFromTaskId: string;
+    coversToTaskId: string;
+    contentFingerprint?: string;
+}
+export interface CompleteThreadHighlightRegenerationInput extends ThreadActorInput {
+    runId: string;
+    threadId: string;
+    workspaceId: string;
+    detectorVersion: string;
+    agentId?: string | null;
+    candidates: readonly ThreadHighlightRegenerationCandidate[];
+}
+export interface CompleteThreadHighlightRegenerationResult {
+    run: ThreadHighlightRun;
+    deletedCount: number;
+    createdCount: number;
+    previousAutoCount: number;
+    newAutoCount: number;
+}
+export declare const THREAD_HIGHLIGHT_DELETION_REASON_REGENERATION_REPLACED: "regeneration_replaced";
+export type ThreadHighlightDeletionReason = typeof THREAD_HIGHLIGHT_DELETION_REASON_REGENERATION_REPLACED;
+export declare const THREAD_HIGHLIGHT_REGENERATION_NO_ELIGIBLE_TURNS: "THREAD_HIGHLIGHT_REGENERATION_NO_ELIGIBLE_TURNS";
+export declare const THREAD_HIGHLIGHT_REGENERATION_INTERRUPTED: "THREAD_HIGHLIGHT_REGENERATION_INTERRUPTED";
+export declare const THREAD_HIGHLIGHT_REGENERATION_DETECTION_FAILED: "THREAD_HIGHLIGHT_REGENERATION_DETECTION_FAILED";
+export declare const THREAD_HIGHLIGHT_REGENERATION_COMMIT_FAILED: "THREAD_HIGHLIGHT_REGENERATION_COMMIT_FAILED";
+export type ThreadHighlightRegenerationErrorCode = typeof THREAD_HIGHLIGHT_REGENERATION_NO_ELIGIBLE_TURNS | typeof THREAD_HIGHLIGHT_REGENERATION_INTERRUPTED | typeof THREAD_HIGHLIGHT_REGENERATION_DETECTION_FAILED | typeof THREAD_HIGHLIGHT_REGENERATION_COMMIT_FAILED | string;
+export declare class ThreadHistoryConflictError extends RepositoryError {
+    readonly threadId: string;
+    readonly highlightId: string;
+    readonly expectedRevision: number;
+    readonly currentRevision: number;
+    constructor(threadId: string, highlightId: string, expectedRevision: number, currentRevision: number);
+}
+export declare class ThreadHighlightConflictError extends ThreadHistoryConflictError {
+}
+export declare class ThreadHighlightRegenerationConflictError extends RepositoryError {
+    readonly stableCode: "THREAD_HIGHLIGHT_REGENERATION_IN_PROGRESS";
+    readonly run: ThreadHighlightRun;
+    constructor(run: ThreadHighlightRun);
+}
+export declare class ThreadHistoryRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private findThread;
+    private findRegenerationRun;
+    resolveWorkspaceId(threadId: string): string | null;
+    getSnapshot(threadId: string, workspaceId?: string | null): ThreadSnapshot | null;
+    updateSnapshot(input: ThreadSnapshotMutationInput): ThreadSnapshot;
+    mutateSnapshot(input: ThreadSnapshotMutationInput): ThreadSnapshot;
+    updateThreadSnapshot(input: ThreadSnapshotMutationInput): ThreadSnapshot;
+    getLatestSeq(threadId: string, workspaceId?: string | null): number | null;
+    listCompletedThreadHighlightTurns(threadId: string, workspaceId: string): ThreadHighlightEligibleTurn[] | null;
+    createHighlightRegenerationRun(input: CreateThreadHighlightRegenerationRunInput): CreateThreadHighlightRegenerationRunResult;
+    beginHighlightRegenerationRun(input: CreateThreadHighlightRegenerationRunInput): CreateThreadHighlightRegenerationRunResult;
+    queueHighlightRegenerationRun(input: CreateThreadHighlightRegenerationRunInput): CreateThreadHighlightRegenerationRunResult;
+    getHighlightRegenerationRun(runId: string, workspaceId?: string): ThreadHighlightRun | null;
+    getHighlightRegenerationRunByRequest(threadId: string, workspaceId: string, requestId: string): ThreadHighlightRun | null;
+    findHighlightRegenerationRun(threadId: string, workspaceId: string, requestId: string): ThreadHighlightRun | null;
+    startHighlightRegenerationRun(runId: string, workspaceId?: string): ThreadHighlightRun;
+    startHighlightRegeneration(runId: string, workspaceId?: string): ThreadHighlightRun;
+    failHighlightRegenerationRun(input: FailThreadHighlightRegenerationRunInput): ThreadHighlightRun;
+    failHighlightRegeneration(input: FailThreadHighlightRegenerationRunInput): ThreadHighlightRun;
+    recoverInterruptedHighlightRegenerationRuns(errorCode?: string): number;
+    completeHighlightRegenerationRun(input: CompleteThreadHighlightRegenerationInput): CompleteThreadHighlightRegenerationResult;
+    completeHighlightRegeneration(input: CompleteThreadHighlightRegenerationInput): CompleteThreadHighlightRegenerationResult;
+    replaceAutoHighlightsAtomically(input: CompleteThreadHighlightRegenerationInput): CompleteThreadHighlightRegenerationResult;
+    listTimeline(query: ThreadTimelineQuery): ThreadTimeline | null;
+    listTimeline(threadId: string, workspaceId: string, options?: ThreadTimelineOptions): ThreadTimeline | null;
+    listEvents(threadId: string, workspaceId: string, options?: ThreadTimelineOptions): ThreadTimeline | null;
+    getTimeline(threadId: string, workspaceId: string, options?: ThreadTimelineOptions): ThreadTimeline | null;
+    createHighlight(input: CreateThreadHighlightInput): ThreadHighlight;
+    updateHighlight(input: UpdateThreadHighlightInput): ThreadHighlight;
+    dismissHighlight(input: DismissThreadHighlightInput): ThreadHighlight;
+    listActiveHighlights(threadId: string, workspaceId: string, options?: ListActiveHighlightsOptions): ThreadHighlight[] | null;
+    listHighlights(threadId: string, workspaceId: string, options?: ListActiveHighlightsOptions): ThreadHighlight[] | null;
+    getActiveHighlights(threadId: string, workspaceId: string, options?: ListActiveHighlightsOptions): ThreadHighlight[] | null;
+}

package/dist/repository/thread-title-common-code-migration.d.ts

@@ -0,0 +1,13 @@
+export interface ThreadTitleCommonCodeMigrationOptions {
+    dbPath?: string;
+    dbRoot?: string;
+    configuredLabels?: readonly string[];
+}
+export interface ThreadTitleCommonCodeMigrationResult {
+    migratedRows: number;
+    createdCodes: number;
+    remainingCustomReferences: number;
+    orphanReferences: number;
+}
+export declare function migrateLegacyThreadTitleCommonCodes(options?: ThreadTitleCommonCodeMigrationOptions): ThreadTitleCommonCodeMigrationResult;
+export declare const migrateThreadTitleCommonCodes: typeof migrateLegacyThreadTitleCommonCodes;