@crewx/sdk 0.9.0-rc.11 → 0.9.0-rc.111

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

@@ -1,20 +1,107 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
 import { tasks } from '../schema/index.js';
-export type TaskRow = typeof tasks.$inferSelect;
+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 = typeof tasks.$inferSelect;
+export type TaskRow = Omit<RawTaskRow, 'status'> & {
+    status: TaskStatus;
+};
 export type NewTask = typeof tasks.$inferInsert;
+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'>;
+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 type WorkflowParentTaskKind = 'workflow_card' | 'workflow_ui_instance';
+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;
@@ -24,6 +111,20 @@ export interface TrendRow {
 export interface ProviderUsageRow {
     provider: string;
     totalTasks: number;
+    unavailableTaskCount?: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+    totalTokens: number;
+    activeDurationMs: number;
+    lastActiveAt: string | null;
+}
+export interface ModelUsageRow {
+    model: string;
+    provider: string;
+    totalTasks: number;
+    unavailableTaskCount?: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
@@ -32,19 +133,84 @@ export interface ProviderUsageRow {
     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 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 lastReaperTickAt?;
     private readonly pidNullObservedSince;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
+        clock?: () => number;
     });
     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;
@@ -56,6 +222,8 @@ 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;
@@ -63,6 +231,22 @@ export declare class TaskRepository extends BaseSqliteRepository {
         renderedPrompt?: string | null;
         codingAgentCommand?: string | null;
     }): void;
+    updateTaskOwnership(opts: {
+        id: string;
+        runEpoch: number;
+        ownership: 'runner' | 'caller';
+        providerPid?: number | null;
+        runtime?: {
+            model?: string | null;
+            renderedPrompt?: 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;
@@ -77,20 +261,33 @@ 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[];
     getTask(id: string): TaskRow | undefined;
-    killTask(id: string): {
-        killed: boolean;
-        pid?: number;
-    };
-    reapOrphanedTasks(): number;
+    killTask(id: string): Promise<TaskKillResult>;
+    reapOrphanedTasks(options?: ReapOrphanedTasksOptions): number;
+    reapRunningWorkflowTasks(graceMs?: number): number;
     findTaskStatus(taskId: string, workspaceId?: string): TaskRow | undefined;
     findChildTasks(parentTaskId: string, workspaceId?: string): TaskRow[];
     getWorkspaceUsageSummary(workspaceId?: string): Array<{
@@ -105,7 +302,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;
@@ -126,7 +330,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;
-    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[];
 }

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.types.d.ts

@@ -0,0 +1,29 @@
+export declare const THREAD_PRIORITIES: readonly ["urgent", "high", "medium", "low"];
+export type ThreadPriority = (typeof THREAD_PRIORITIES)[number];
+export declare const BUILTIN_THREAD_STATES: readonly ["investigating", "in-progress", "in-review", "on-hold", "done"];
+export type BuiltinThreadState = (typeof BUILTIN_THREAD_STATES)[number];
+export type StableThreadState = BuiltinThreadState | `c_${string}`;
+export type LegacyThreadState = `custom:${string}`;
+export type ThreadState = StableThreadState | LegacyThreadState;
+export interface ThreadTitleMeta {
+    priority?: ThreadPriority;
+    state?: ThreadState;
+}
+export interface ThreadTitlePatch {
+    priority?: ThreadPriority | null;
+    state?: ThreadState | null;
+}
+export declare function isThreadPriority(value: unknown): value is ThreadPriority;
+export declare function isThreadState(value: unknown): value is ThreadState;
+export declare function customStateLabel(state: ThreadState): string | undefined;
+export declare function hasThreadTitleKey(metadataJson: string | null | undefined): boolean;
+export declare function readThreadTitleMeta(metadataJson: string | null | undefined): ThreadTitleMeta;
+export declare function mergeThreadTitleMeta(metadataJson: string | null | undefined, patch: ThreadTitlePatch): string | null;
+export declare function threadTitleSearchHaystack(meta: ThreadTitleMeta, labelNames?: ReadonlyMap<string, string>): string;
+export interface ThreadTitleFilter {
+    values: Set<string>;
+    includeNone: boolean;
+}
+export declare function parseThreadPriorityFilter(raw: string | undefined): ThreadTitleFilter | undefined;
+export declare function parseThreadStateFilter(raw: string | undefined): ThreadTitleFilter | undefined;
+export declare function matchesThreadTitleFilter(current: string | undefined, filter: ThreadTitleFilter | undefined): boolean;

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

@@ -1,8 +1,35 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { RepositoryError } from './errors.js';
 import { threads } from '../schema/index.js';
-import type { TaskRow } from './task.repository.js';
+import type { TaskRow, TaskListRow } from './task.repository.js';
 export type ThreadRow = typeof threads.$inferSelect;
 export type NewThread = typeof threads.$inferInsert;
+export type ThreadActorKind = NonNullable<NewThread['created_by_kind']>;
+export interface ThreadCreationOptions {
+    createdByKind?: ThreadActorKind | null;
+    createdById?: string | null;
+    createdByTaskId?: string | null;
+}
+export type ThreadOriginFilter = 'direct' | 'delegated' | 'all';
+type ThreadOriginScope = Exclude<ThreadOriginFilter, 'all'>;
+export interface ThreadOriginRow {
+    origin: 'direct' | 'delegated';
+    delegatedByAgentId: string | null;
+}
+export interface ThreadTitleMetadataPatch {
+    priority?: string | null;
+    state?: string | null;
+}
+export interface ThreadTitleMetadataPatchResult {
+    threadId: string;
+    priority: string | null;
+    state: string | null;
+}
+export type ThreadTitleMetadataPatchErrorReason = 'THREAD_TITLE_PATCH_EMPTY' | 'THREAD_TITLE_PATCH_INVALID';
+export declare class ThreadTitleMetadataPatchError extends RepositoryError {
+    readonly reason: ThreadTitleMetadataPatchErrorReason;
+    constructor(reason: ThreadTitleMetadataPatchErrorReason, message?: string);
+}
 export declare class ThreadRepository extends BaseSqliteRepository {
     private readonly dbPath?;
     constructor(opts?: {
@@ -13,7 +40,10 @@ export declare class ThreadRepository extends BaseSqliteRepository {
     private openHandle;
     private validateWorkspaceId;
     private topLevelTaskPredicateSql;
-    findAllThreads(workspaceId?: string): ThreadRow[];
+    private findAllThreadsQuery;
+    findAllThreads(workspaceId?: string, createdByKind?: ThreadActorKind): ThreadRow[];
+    explainFindAllThreadsPlan(workspaceId?: string, createdByKind?: ThreadActorKind): string[];
+    findThreadsByIdsOrTitles(ids: string[], workspaceId?: string): ThreadRow[];
     findThreadById(threadId: string, workspaceId?: string): ThreadRow | undefined;
     threadExists(threadId: string, workspaceId?: string): boolean;
     aggregateTaskStats(threadId: string, workspaceId?: string): {
@@ -30,15 +60,25 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         task: TaskRow;
         children: TaskRow[];
     } | undefined;
-    batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskRow[]>;
+    private batchFetchTasksQuery;
+    batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskListRow[]>;
+    private findThreadOriginsQuery;
+    private findRecordedThreadOriginsQuery;
+    private findThreadsByOriginQuery;
+    private findLegacyThreadsQuery;
+    findThreadOrigins(threadIds: string[], workspaceId?: string): Map<string, ThreadOriginRow>;
+    findThreadsByOrigin(origin: ThreadOriginScope, workspaceId?: string): ThreadRow[];
+    explainBatchFetchTasksPlan(threadIds: string[], workspaceId?: string): string[];
+    explainFindThreadOriginsPlan(threadIds: string[], workspaceId?: string): string[];
+    explainFindThreadsByOriginPlan(origin: ThreadOriginScope, workspaceId?: string): string[];
     updateThreadTitle(threadId: string, title: string, workspaceId?: string): void;
     upsertThread(threadId: string, opts: {
         platform: string;
         workspaceId?: string;
         title?: string;
         titleLocked?: boolean;
-    }): void;
-    ensureThread(threadId: string, platform: string, workspaceId?: string): void;
+    } & ThreadCreationOptions): void;
+    ensureThread(threadId: string, platform: string, workspaceId?: string, creator?: ThreadCreationOptions): void;
     saveUserMessage(threadId: string, text: string, opts?: {
         platform?: string;
         model?: string;
@@ -56,6 +96,7 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         title?: string;
         titleLocked?: boolean;
     }): void;
+    patchThreadTitleMetadata(threadId: string, patch: ThreadTitleMetadataPatch, workspaceId?: string): ThreadTitleMetadataPatchResult | ThreadTitleMetadataPatchError | null;
     togglePin(threadId: string, workspaceId?: string): {
         pinned: boolean;
     } | null;
@@ -75,3 +116,4 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         remaining: number;
     } | null;
 }
+export {};