import { type DelegationCategory, type DelegationRoutingTelemetry } from "./router.js";
export type TaskStatus = "queued" | "blocked" | "running" | "succeeded" | "failed" | "cancelled";
export type TaskMergeStatus = "pending" | "verified" | "deferred" | "merged" | "conflicted" | "dirty_root" | "failed" | "bypassed";
export type TaskVerificationStatus = "pending" | "passed" | "failed" | "not_required";
export type TaskVerificationStrategy = "targeted" | "fallback" | "not_required";
export type TaskRootFollowThroughStatus = "pending" | "delivered" | "waived";
export type TaskAssignmentOwner = "manager";
export type TaskAssignmentWorkflow = "caid";
export type TaskRetryReason = "merge_conflict" | "dirty_root";
export type TaskRetryState = "idle" | "blocked" | "resync_required" | "ready";
export type TaskResyncStatus = "pending" | "succeeded" | "failed";
export type TaskReviewStatus = "not_required" | "pending" | "running" | "complete" | "blocked";
export interface TaskAssignmentRetryRecord {
    reason?: TaskRetryReason;
    state?: TaskRetryState;
    last_resync_status?: TaskResyncStatus;
    last_resync_at?: string;
    last_resync_summary?: string;
}
export interface TaskAssignmentVerificationRecord {
    strategy?: TaskVerificationStrategy;
    candidate_commands?: string[];
    selected_command?: string;
    fallback_command?: string;
    selection_reason?: string;
}
export interface TaskAssignmentReviewRecord {
    status?: TaskReviewStatus;
    summary?: string;
    reviewed_at?: string;
}
export interface TaskAssignmentRecord {
    owner: TaskAssignmentOwner;
    workflow: TaskAssignmentWorkflow;
    dependency_ids?: string[];
    retry?: TaskAssignmentRetryRecord;
    verification?: TaskAssignmentVerificationRecord;
    review?: TaskAssignmentReviewRecord;
}
export interface TaskExecutionRecord {
    mode: "direct" | "worktree";
    branch?: string;
    base_branch?: string;
    worktree_path?: string;
    effective_root_path?: string;
    merge_status?: TaskMergeStatus;
    verification_status?: TaskVerificationStatus;
    verification_strategy?: TaskVerificationStrategy;
    verification_candidates?: string[];
    verification_fallback_reason?: string;
    verification_command?: string;
    verification_summary?: string;
    diff_summary?: string;
    root_follow_through?: {
        status: TaskRootFollowThroughStatus;
        updated_at: string;
        reason?: string;
        source?: string;
    };
    read_count?: number;
    search_count?: number;
    planning_count?: number;
    edit_count?: number;
    other_count?: number;
    file_changed?: boolean;
    edit_or_blocked_threshold?: number;
    stale_reason?: string;
    retry_count?: number;
}
export interface TaskRecord {
    id: string;
    root_session_id: string;
    parent_session_id: string;
    child_session_id: string;
    description: string;
    agent: string;
    prompt: string;
    authoritative_context?: string;
    command?: string;
    category?: DelegationCategory;
    routing?: DelegationRoutingTelemetry;
    depends_on?: string[];
    concurrency_key?: string;
    assignment?: TaskAssignmentRecord;
    execution?: TaskExecutionRecord;
    run_in_background: boolean;
    status: TaskStatus;
    created_order?: number;
    created_at: string;
    updated_at: string;
    started_at?: string;
    completed_at?: string;
    result?: string;
    error?: string;
}
interface TaskStore {
    version: 3;
    delegations: Record<string, TaskRecord>;
}
export declare function isManagerOwnedCAIDTask(record: Pick<TaskRecord, "assignment">): boolean;
export declare function createTaskStateManager(workspaceDir: string, logger?: {
    debug: (message: string, extras?: {
        [x: string]: unknown;
    }) => void;
    info: (message: string, extras?: {
        [x: string]: unknown;
    }) => void;
    warn: (message: string, extras?: {
        [x: string]: unknown;
    }) => void;
    error: (message: string, extras?: {
        [x: string]: unknown;
    }) => void;
}): {
    readStore: () => Promise<TaskStore>;
    createTask: (input: {
        id: string;
        root_session_id: string;
        parent_session_id: string;
        child_session_id: string;
        description: string;
        agent: string;
        prompt: string;
        authoritative_context?: string;
        command?: string;
        category?: DelegationCategory;
        routing?: DelegationRoutingTelemetry;
        depends_on?: string[];
        concurrency_key?: string;
        assignment?: TaskAssignmentRecord;
        execution?: TaskExecutionRecord;
        run_in_background: boolean;
        initial_status?: "queued" | "blocked" | "running";
    }) => Promise<TaskRecord>;
    transitionTask: (id: string, nextStatus: TaskStatus, patch?: {
        result?: string;
        error?: string;
    }) => Promise<TaskRecord>;
    restartTask: (input: {
        id: string;
        child_session_id?: string;
        description?: string;
        prompt: string;
        authoritative_context?: string;
        command?: string;
        category?: DelegationCategory;
        routing?: DelegationRoutingTelemetry;
        depends_on?: string[];
        concurrency_key?: string;
        assignment?: TaskAssignmentRecord;
        execution?: TaskExecutionRecord;
        run_in_background: boolean;
        initial_status?: "queued" | "blocked" | "running";
    }) => Promise<TaskRecord>;
    updateTask: (id: string, patch: {
        command?: string;
        assignment?: TaskAssignmentRecord;
        execution?: TaskExecutionRecord;
        result?: string;
        error?: string;
    }) => Promise<TaskRecord>;
    getTask: (id: string) => Promise<TaskRecord | null>;
    getTaskByChildSessionID: (childSessionID: string) => Promise<TaskRecord | null>;
    listTasks: (filter?: {
        root_session_id?: string;
        status?: TaskStatus;
        limit?: number;
        concurrency_key?: string;
        run_in_background?: boolean;
    }) => Promise<TaskRecord[]>;
    listRunnableBlockedTasks: (filter?: {
        root_session_id?: string;
        limit?: number;
    }) => Promise<TaskRecord[]>;
    listRunnableQueuedTasks: (limit?: number) => Promise<TaskRecord[]>;
    listPromotableTasks: (filter?: {
        root_session_id?: string;
        limit?: number;
    }) => Promise<TaskRecord[]>;
    getBlockingDependencies: (id: string) => Promise<string[]>;
};
export type TaskStateManager = ReturnType<typeof createTaskStateManager>;
export {};
//# sourceMappingURL=state.d.ts.map