@crewx/sdk 0.9.0-rc.20 → 0.9.0-rc.201

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-origin-verdict.d.ts

@@ -0,0 +1,27 @@
+export type ThreadOriginKind = 'human' | 'agent' | 'system';
+export interface ThreadOriginRow {
+    origin: 'direct' | 'delegated';
+    delegatedByAgentId: string | null;
+}
+export interface RawThreadOriginRow {
+    task_id: string;
+    thread_id: string;
+    caller_agent_id: string | null;
+    parent_task_id: string | null;
+    schedule_id: unknown;
+    platform: string | null;
+    parent_thread_id: string | null;
+    parent_agent_id: string | null;
+}
+export interface RawThreadCreatorPointerRow {
+    thread_id: string;
+    created_by_kind: string | null;
+    created_by_id: string | null;
+    created_by_task_id: string | null;
+    creator_task_id: string | null;
+    creator_actor_kind: string | null;
+    creator_actor_id: string | null;
+    creator_pointer_unverified: number;
+}
+export declare function lineageThreadOrigin(row: RawThreadOriginRow): ThreadOriginRow;
+export declare function resolveThreadOrigin(row: RawThreadCreatorPointerRow, pointerLineage?: RawThreadOriginRow, fallbackLineage?: RawThreadOriginRow): ThreadOriginRow | undefined;

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,96 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { DrizzleHandle } from './db.js';
+import { RepositoryError } from './errors.js';
 import { threads } from '../schema/index.js';
+import { type TaskStatus } from './task-status.js';
+import type { UnreadReplyCandidate } from './public-task-answer.js';
+import type { ThreadOriginRow } from './thread-origin-verdict.js';
 import type { TaskRow, TaskListRow } from './task.repository.js';
+export type { ThreadOriginRow } from './thread-origin-verdict.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 interface CreateAppLaunchThreadInput {
+    threadId: string;
+    workspaceId: string;
+    platform: string;
+    title: string;
+    appId: string;
+    createdById: string | null;
+    initialAgentId?: string;
+}
+export type CreateAppLaunchThreadResult = {
+    status: 'created';
+    thread: ThreadRow;
+} | {
+    status: 'existing';
+    thread: ThreadRow;
+} | {
+    status: 'conflict';
+};
+export interface UnreadReplyWatermark {
+    threadId: string;
+    readThroughAt: string | null;
+}
+export interface TaskDescendantSummary {
+    total: number;
+    running: number;
+    pending: number;
+    paused: number;
+    success: number;
+    failed: number;
+    stopped: number;
+    runnerLost: number;
+    checkedAt: string;
+}
+export interface RespondedAgent {
+    agentId: string;
+    lastRepliedAt: string;
+}
+export interface TaskDescendantRow {
+    task: TaskRow;
+    parentTaskId: string;
+    parentAgentId: string | null;
+    depth: number;
+}
+export interface TaskDescendantListOptions {
+    states?: readonly TaskStatus[];
+    limit?: number;
+    cursor?: string | null;
+    maxDepth?: number;
+}
+export interface TaskDescendantList {
+    rows: TaskDescendantRow[];
+    summary: TaskDescendantSummary;
+    nextCursor: string | null;
+    traversalTruncated: boolean;
+}
+export type ThreadOriginFilter = 'direct' | 'delegated' | 'all';
+type ThreadOriginScope = Exclude<ThreadOriginFilter, 'all'>;
+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 type ThreadTransaction = Parameters<Parameters<DrizzleHandle['db']['transaction']>[0]>[0];
+export declare function toggleThreadPinInTx(tx: ThreadTransaction, threadId: string, workspaceId?: string): {
+    pinned: boolean;
+} | null;
+export declare function reorderPinsInTx(tx: ThreadTransaction, threadIds: string[], workspaceId?: string): void;
 export declare class ThreadRepository extends BaseSqliteRepository {
     private readonly dbPath?;
     constructor(opts?: {
@@ -11,10 +99,22 @@ export declare class ThreadRepository extends BaseSqliteRepository {
     });
     resolveDbPath(): string;
     private openHandle;
-    private validateWorkspaceId;
     private topLevelTaskPredicateSql;
-    findAllThreads(workspaceId?: string): ThreadRow[];
+    private workflowAnchorPredicateSql;
+    private descendantTraversalSql;
+    private descendantSkippedSql;
+    private findAllThreadsQuery;
+    private findThreadIdsQuery;
+    private readThreadIds;
+    private findThreadSortKeysQuery;
+    private readThreadSortKeys;
+    private readThreadRowsByIds;
+    private readThreadRows;
+    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;
+    createAppLaunchThread(input: CreateAppLaunchThreadInput): CreateAppLaunchThreadResult;
     threadExists(threadId: string, workspaceId?: string): boolean;
     aggregateTaskStats(threadId: string, workspaceId?: string): {
         taskCount: number;
@@ -23,24 +123,52 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         cachedInputTokens: number;
         costUsd: number;
         agentIds: string[];
+        delegated: {
+            taskCount: number;
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            costUsd: number;
+        };
     };
-    findTopLevelTasks(threadId: string, workspaceId?: string, limit?: number): TaskRow[];
+    getDescendantSummaryByTaskId(threadId: string, workspaceId?: string): Record<string, TaskDescendantSummary>;
+    listUnreadReplyCandidates(watermarks: readonly UnreadReplyWatermark[], workspaceId?: string): Map<string, UnreadReplyCandidate[]>;
+    private unreadReplyCandidatesQuery;
+    getThreadTaskStatusBatch(threadIds: string[], workspaceId?: string): {
+        tasksByThread: Map<string, TaskListRow[]>;
+        descendantSummaryByTaskId: Record<string, TaskDescendantSummary>;
+    };
+    listDescendantsByTaskId(taskId: string, workspaceId: string, options?: TaskDescendantListOptions): TaskDescendantList | undefined;
+    findInterceptedRequests(taskIds: readonly string[]): Map<string, string>;
+    findTopLevelTasks(threadId: string, workspaceId?: string, limit?: number, ownAgentId?: string): TaskRow[];
     findAllTasks(threadId: string, workspaceId?: string): TaskRow[];
+    findRespondedAgents(threadId: string, workspaceId?: string): RespondedAgent[];
     findTaskById(threadId: string, taskId: string, workspaceId?: string): {
         task: TaskRow;
         children: TaskRow[];
     } | undefined;
     private batchFetchTasksQuery;
     batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskListRow[]>;
+    private findThreadOriginsQuery;
+    private findCreatorPointersQuery;
+    private findTaskOriginLineageQuery;
+    findThreadOrigins(threadIds: string[], workspaceId?: string): Map<string, ThreadOriginRow>;
+    findThreadsByOrigin(origin: ThreadOriginScope, workspaceId?: string): ThreadRow[];
+    findRecentDirectThreads(workspaceId: string, limit?: number): {
+        threads: ThreadRow[];
+        originsByThread: Map<string, ThreadOriginRow>;
+    };
     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;
@@ -58,6 +186,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;

package/dist/repository/usage-backfill.d.ts

@@ -0,0 +1,62 @@
+export type UsageBackfillMode = 'dry-run' | 'apply' | 'verify' | 'restore';
+export declare const USAGE_BACKFILL_TERMINAL_STATUSES: readonly ["success", "failed", "completed"];
+export declare const USAGE_BACKFILL_MAX_LATE_USAGE_AGE_MS: number;
+export declare const USAGE_BACKFILL_UNDO_SCHEMA_VERSION = 2;
+export declare const USAGE_BACKFILL_SNAPSHOT_ROW_BYTES = 2048;
+export declare const USAGE_BACKFILL_MIN_FREE_SPACE_RESERVE_BYTES: number;
+export type UsageAccountingReason = 'pre-instrumentation' | 'provider-no-usage' | 'suppressed-by-adapter' | 'not-captured';
+export interface UsageBackfillOptions {
+    mode: UsageBackfillMode;
+    dbPath?: string;
+    backupPath?: string;
+    restorePath?: string;
+    now?: Date | string | number;
+}
+export interface UsageBackfillProviderStats {
+    candidates: number;
+    recovered: number;
+    unavailable: number;
+    deferred: number;
+}
+export interface UsageBackfillFailure {
+    taskId: string;
+    reason: string;
+}
+export interface UsageBackfillReport {
+    mode: UsageBackfillMode;
+    ok: boolean;
+    dbPath: string;
+    scannedTasks: number;
+    terminalTasks: number;
+    rawTargetTasks: number;
+    candidateTasks: number;
+    recoveredTasks: number;
+    unavailableTasks: number;
+    deferredTasks: number;
+    changedTasks: number;
+    wouldChangeTasks: number;
+    accountingTasks: number;
+    remainingTargetTasks: number;
+    providerDistribution: Record<string, UsageBackfillProviderStats>;
+    reasonCounts: Record<UsageAccountingReason, number>;
+    estimatedFreeSpaceBytes: number;
+    requiredFreeSpaceBytes: number;
+    availableFreeSpaceBytes: number;
+    minimumFreeSpaceReserveBytes: number;
+    freeSpaceGatePassed: boolean;
+    backupPath?: string;
+    snapshotPath?: string;
+    backupMethod?: 'row-undo-snapshot';
+    restored: number;
+    skippedConflict: number;
+    conflictSamples: UsageBackfillConflict[];
+    blockedReason?: string;
+    failures: UsageBackfillFailure[];
+    warnings: string[];
+}
+export interface UsageBackfillConflict {
+    taskId: string;
+    fields: string[];
+}
+export declare function classifyUsageAccountingReason(provider: string | undefined, stdout?: string): UsageAccountingReason;
+export declare function runUsageBackfill(options: UsageBackfillOptions): Promise<UsageBackfillReport>;

package/dist/repository/usage-from-logs.d.ts

@@ -0,0 +1,22 @@
+import type { CliProviderAdapter } from '../provider/cli/adapter.types.js';
+import type { TaskLogRepositoryContract } from './task-log.repository.js';
+export interface RecoveredTaskUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+    model: string | null;
+    complete?: boolean;
+}
+export interface TaskLogUsageRecovery {
+    stdout: string;
+    adapter: CliProviderAdapter;
+    usage?: RecoveredTaskUsage;
+}
+export interface RecoverUsageFromTaskLogsOptions {
+    taskLogRepository: Pick<TaskLogRepositoryContract, 'readLogs'>;
+    taskId: string;
+    provider?: string | null;
+    model?: string | null;
+}
+export declare function recoverUsageFromTaskLogs(options: RecoverUsageFromTaskLogsOptions): TaskLogUsageRecovery | undefined;

package/dist/repository/workflow-anchor-kinds.d.ts

@@ -0,0 +1,4 @@
+export declare const WORKFLOW_ANCHOR_TASK_KINDS: readonly ["workflow_card", "workflow_ui_instance", "workflow_run"];
+export type WorkflowAnchorTaskKind = (typeof WORKFLOW_ANCHOR_TASK_KINDS)[number];
+export declare function isWorkflowAnchorTaskKind(value: unknown): value is WorkflowAnchorTaskKind;
+export declare function readWorkflowRunIdFromMetadata(metadata: string | null | undefined): string | null;

package/dist/repository/workspace.repository.d.ts

@@ -48,6 +48,9 @@ export declare class WorkspaceRepository extends BaseSqliteRepository {
         total: number;
     };
     findById(id: string): ProjectRow | undefined;
+    toggleStar(id: string): {
+        starred: boolean;
+    } | null;
     findAgentsByProject(id: string): string[];
     findThreadsByProject(id: string, params: {
         limit: number;

package/dist/route/decide.d.ts

@@ -0,0 +1,54 @@
+import type { RouteObservationSource } from './eligibility.js';
+import type { RouteCandidate, RouteConfig, RouteDecision, RouteLinkError, RouteRequest, RouteRunner } from './types.js';
+import type { RouteDecisionStore } from './store.js';
+export interface RouteDecisionServiceOptions {
+    store: RouteDecisionStore;
+    observationSource?: RouteObservationSource;
+    workspaceRoot?: string;
+    clock?: () => number;
+    chainTimeoutMs?: number;
+    maxCasRetries?: number;
+    customRunners?: Readonly<Record<string, RouteRunner>>;
+    linkRunnerOverrides?: Readonly<Record<string, RouteRunner>>;
+}
+export interface RecordRouteQuotaFailureInput {
+    decision: RouteDecision;
+    accountRef?: string;
+    resetAt?: number | string;
+    now?: number;
+}
+export interface RoutePreviewItem {
+    candidateId: string;
+    provider: string;
+    model: string;
+    reason: string;
+    eligibleIds: string[];
+    blockedCauses: RouteDecision['blockedCauses'];
+    linkErrors: RouteLinkError[];
+}
+export declare function routeConfigRevision(route: RouteConfig): string;
+export declare class RouteDecisionService {
+    private readonly store;
+    private readonly observationSource?;
+    private readonly workspaceRoot;
+    private readonly clock;
+    private readonly chainTimeoutMs;
+    private readonly maxCasRetries;
+    private readonly customRunners;
+    private readonly linkRunnerOverrides;
+    private readonly routeLocks;
+    constructor(options: RouteDecisionServiceOptions);
+    private links;
+    private withRouteLock;
+    private decideSerial;
+    decide(routeId: string, route: RouteConfig, request: RouteRequest): Promise<RouteDecision>;
+    previewRoute(routeId: string, route: RouteConfig, request: RouteRequest, count?: number): Promise<RoutePreviewItem[]>;
+    recordQuotaFailure(input: RecordRouteQuotaFailureInput): Promise<void>;
+}
+export declare function previewRoute(route: RouteConfig, count: number, options?: {
+    routeId?: string;
+    candidates?: RouteCandidate[];
+    now?: number;
+    agentId?: string;
+    mode?: RouteRequest['mode'];
+}): RoutePreviewItem[];

package/dist/route/eligibility.d.ts

@@ -0,0 +1,11 @@
+import type { RouteBlockedCause, RouteCandidate, RouteCandidateConfig, RouteQuotaObservation } from './types.js';
+export declare const ROUTE_QUOTA_COOLDOWN_MS: number;
+export interface RouteObservationSource {
+    getObservations(candidates: readonly RouteCandidateConfig[], now: number): Promise<RouteQuotaObservation[]> | RouteQuotaObservation[];
+}
+export interface RouteEligibilityResult {
+    candidates: RouteCandidate[];
+    blockedCauses: RouteBlockedCause[];
+}
+export declare function evaluateRouteEligibility(candidates: readonly RouteCandidateConfig[], observations: readonly RouteQuotaObservation[], now: number): RouteEligibilityResult;
+export declare function quotaResetAt(resetAt: number | string | undefined, now: number): number;

package/dist/route/errors.d.ts

@@ -0,0 +1,11 @@
+export type RouteErrorCode = 'route_no_eligible_candidate' | 'route_state_contention' | 'sticky_unavailable' | 'route_observation_unavailable' | 'invalid_route_config';
+export declare class RouteError extends Error {
+    readonly code: RouteErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: RouteErrorCode, message: string, details?: Record<string, unknown> | undefined);
+}
+export type RouteRunnerErrorCode = 'invalid_json' | 'input_too_large' | 'output_too_large' | 'outside_workspace' | 'module_not_found' | 'timeout' | 'process_failed';
+export declare class RouteRunnerError extends Error {
+    readonly code: RouteRunnerErrorCode;
+    constructor(code: RouteRunnerErrorCode, message: string);
+}

package/dist/route/index.d.ts

@@ -0,0 +1,14 @@
+export { RouteConfigSchema, RouteCandidateConfigSchema, RouteLinkConfigSchema } from './types.js';
+export type { JsonPrimitive, JsonValue, RouteBlockedCause, RouteCandidate, RouteCandidateConfig, RouteConfig, RouteContext, RouteDecision, RouteFunction, RouteHealth, RouteLinkConfig, RouteLinkError, RouteMode, RouteOutput, RoutePassOutput, RouteQuotaObservation, RouteRequest, RouteRunner, RouteSelectOutput, } from './types.js';
+export { RouteError, RouteRunnerError } from './errors.js';
+export type { RouteErrorCode, RouteRunnerErrorCode } from './errors.js';
+export { builtInStrategy, roundRobin, smoothWeighted } from './strategies.js';
+export { fnRunner, procRunner, resolveRouteModulePath, ROUTE_CHAIN_TIMEOUT_MS, ROUTE_JSON_MAX_BYTES, ROUTE_PROCESS_INPUT_MAX_BYTES, ROUTE_PROCESS_OUTPUT_MAX_BYTES, } from './runner.js';
+export type { ProcRunnerOptions } from './runner.js';
+export { evaluateRouteEligibility, quotaResetAt, ROUTE_QUOTA_COOLDOWN_MS } from './eligibility.js';
+export type { RouteEligibilityResult, RouteObservationSource } from './eligibility.js';
+export { MemoryRouteStore } from './store.js';
+export type { RouteCommitResult, RouteDecisionCommit, RouteDecisionStore, RouteObservationStore, RouteStateSnapshot, } from './store.js';
+export { RouteSqliteStore } from './sqlite-store.js';
+export { RouteDecisionService, previewRoute, routeConfigRevision } from './decide.js';
+export type { RecordRouteQuotaFailureInput, RouteDecisionServiceOptions, RoutePreviewItem, } from './decide.js';

package/dist/route/runner.d.ts

@@ -0,0 +1,15 @@
+import type { RouteFunction, RouteRunner } from './types.js';
+export declare const ROUTE_JSON_MAX_BYTES: number;
+export declare const ROUTE_PROCESS_INPUT_MAX_BYTES: number;
+export declare const ROUTE_PROCESS_OUTPUT_MAX_BYTES: number;
+export declare const ROUTE_CHAIN_TIMEOUT_MS = 2000;
+export interface ProcRunnerOptions {
+    workspaceRoot: string;
+    timeoutMs?: number;
+    maxInputBytes?: number;
+    maxOutputBytes?: number;
+    onSpawn?: (processGroupId: number | undefined) => void;
+}
+export declare function fnRunner(fn: RouteFunction): RouteRunner;
+export declare function procRunner(file: string, options: ProcRunnerOptions): RouteRunner;
+export declare function resolveRouteModulePath(file: string, workspaceRoot: string): string;

package/dist/route/sqlite-store.d.ts

@@ -0,0 +1,17 @@
+import { BaseSqliteRepository } from '../repository/base-sqlite-repository.js';
+import type { RouteDecision, RouteQuotaObservation, RouteCandidateConfig } from './types.js';
+import type { RouteDecisionCommit, RouteDecisionStore, RouteObservationStore, RouteStateSnapshot, RouteCommitResult } from './store.js';
+export declare class RouteSqliteStore extends BaseSqliteRepository implements RouteDecisionStore, RouteObservationStore {
+    private readonly configuredDbPath?;
+    constructor(options?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    getDecision(routeId: string, taskId: string): Promise<RouteDecision | undefined>;
+    loadState(routeId: string, threadId: string | null, configRevision: string): Promise<RouteStateSnapshot>;
+    commitDecision(input: RouteDecisionCommit): Promise<RouteCommitResult>;
+    recordQuotaObservation(observation: RouteQuotaObservation, observedAt: number): Promise<void>;
+    getObservations(candidates: readonly RouteCandidateConfig[], _now: number): Promise<RouteQuotaObservation[]>;
+}