import type { SessionId, TaskId, TenantId, TurnId } from '../ids/index.js';
/**
 * `failed` exists because a unit that did not succeed had nowhere to say so.
 *
 * Delegation wrote a failed worker's task as `completed` with the failure
 * encoded as prose in `description` — so a reader scanning statuses saw work
 * that had been done, and only a reader of every description saw otherwise. A
 * status nobody can set is a status nobody can act on: a dependent unit cannot
 * decide whether to wait or give up, and a plan cannot report that it did not
 * finish.
 */
export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
/**
 * Terminal means "will not change on its own", not "succeeded".
 *
 * `failed` is terminal for the same reason `completed` is: nothing downstream
 * should wait on it. That matters most to the blocker check in the task
 * listing — a dependent unit blocked on something that failed would otherwise
 * wait forever for a status that will never arrive.
 */
export declare function isTerminalTaskStatus(status: TaskStatus): boolean;
export declare function assertTaskStatus(status: TaskStatus): void;
export interface Task {
    readonly id: TaskId;
    /** The session the task belongs to (`<session-id>/tasks/`). */
    readonly sessionId: SessionId;
    /** The turn that created the task. */
    readonly turnId: TurnId;
    readonly tenantId?: TenantId;
    subject: string;
    description?: string;
    activeForm?: string;
    status: TaskStatus;
    owner?: string;
    blocks: TaskId[];
    blockedBy: TaskId[];
    metadata?: Record<string, unknown>;
    createdAt: number;
    startedAt?: number;
    completedAt?: number;
}
export type TaskEventType = 'task.created' | 'task.updated' | 'task.deleted' | 'task.claimed';
export interface TaskEvent {
    type: TaskEventType;
    taskId: TaskId;
    task: Task;
    previousStatus?: TaskStatus;
    timestamp: number;
}
export type TaskEventListener = (event: TaskEvent) => void;
export interface CreateTaskParams {
    sessionId: SessionId;
    turnId: TurnId;
    tenantId?: TenantId;
    subject: string;
    description?: string;
    activeForm?: string;
    owner?: string;
    blockedBy?: TaskId[];
    metadata?: Record<string, unknown>;
}
export interface UpdateTaskParams {
    subject?: string;
    description?: string;
    activeForm?: string;
    status?: TaskStatus;
    owner?: string;
    metadata?: Record<string, unknown>;
}
export interface TaskStore {
    create(params: CreateTaskParams): Promise<Task>;
    get(id: TaskId): Promise<Task | undefined>;
    update(id: TaskId, updates: UpdateTaskParams): Promise<Task | undefined>;
    delete(id: TaskId): Promise<boolean>;
    list(filter?: {
        status?: TaskStatus;
        owner?: string;
        sessionId?: SessionId;
    }): Promise<Task[]>;
    claim(id: TaskId, owner: string): Promise<Task | undefined>;
    block(blockerId: TaskId, blockedId: TaskId): Promise<void>;
    on(listener: TaskEventListener): () => void;
    reset(): Promise<void>;
}
//# sourceMappingURL=index.d.ts.map